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
      arg.as(:arg)
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:configuration) do
      c(
          "rcsid" arg,
          "version" arg,
          "groups" (
              s(
                any
              )
          ),
          "system" (
            juniper_system
          ),
          "dynamic-profiles" (
            juniper_dynamic_profile_object
          ),
          "logical-systems" (
            juniper_logical_system
          ),
          "chassis" (
            chassis_type
          ),
          "services" (
              c(
                  "analytics" (
                      c(
                          "traceoptions" (
                              c(
                                  "no-remote-trace",
                                  "file" (
                                      c(
                                            arg,
                                          "size" arg,
                                          "files" arg,
                                          "world-readable",
                                          "no-world-readable",
                                          "match" (
                                            regular_expression
                                          )
                                      )
                                  ).as(:oneline),
                                  "flag" (("all" | "configuration" | "rtsock" | "client-server" | "interface" | "xmlproxy")) (
                                      c(
                                          "disable"
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "export-profiles" arg (
                              c(
                                  "stream-format" (
                                    ("gpb" | "json" | "csv" | "tsv")
                                  ),
                                  "interface" (
                                      c(
                                          "information",
                                          "statistics" (
                                              c(
                                                  "traffic",
                                                  "queue"
                                              )
                                          ),
                                          "status" (
                                              c(
                                                  "link",
                                                  "traffic",
                                                  "queue"
                                              )
                                          )
                                      )
                                  ),
                                  "system" (
                                      c(
                                          "information",
                                          "status" (
                                              c(
                                                  "traffic",
                                                  "queue"
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "resource-profiles" arg (
                              c(
                                  "queue-monitoring",
                                  "no-queue-monitoring",
                                  "traffic-monitoring",
                                  "no-traffic-monitoring",
                                  "depth-threshold" (
                                      c(
                                          "high" arg,
                                          "low" arg
                                      )
                                  ).as(:oneline),
                                  "latency-threshold" (
                                      c(
                                          "high" arg,
                                          "low" arg
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "resource" (
                              c(
                                  "system" (
                                      c(
                                          "resource-profile" arg,
                                          "polling-interval" (
                                              c(
                                                  "traffic-monitoring" arg,
                                                  "queue-monitoring" arg
                                              )
                                          )
                                      )
                                  ),
                                  "interfaces" (
                                      c(
                                            interface_type
                                      )
                                  )
                              )
                          ),
                          "collector" (
                              c(
                                  "local" (
                                      c(
                                          "file" (
                                              c(
                                                    filename,
                                                  "size" arg,
                                                  "files" arg
                                              )
                                          ).as(:oneline)
                                      )
                                  ),
                                  "address" arg (
                                      c(
                                          "port" arg (
                                              c(
                                                  "transport" (("tcp" | "udp")) (
                                                      c(
                                                          "export-profile" arg
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "traffic-statistics" (
                              c(
                                  "file" (
                                      c(
                                            filename,
                                          "size" arg,
                                          "files" arg
                                      )
                                  ).as(:oneline),
                                  "interval" arg
                              )
                          ),
                          "queue-statistics" (
                              c(
                                  "file" (
                                      c(
                                            filename,
                                          "size" arg,
                                          "files" arg
                                      )
                                  ).as(:oneline),
                                  "interval" arg
                              )
                          ),
                          "interfaces" (
                              c(
                                    interface_type
                              )
                          ),
                          "streaming-servers" (
                              c(
                                  "address" arg (
                                      c(
                                          "port" arg (
                                              c(
                                                  "stream-format" (
                                                    ("json" | "csv" | "tsv")
                                                  ),
                                                  "stream-type" (("traffic-statistics" | "queue-statistics"))
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "streaming-server" arg (
                              c(
                                  "remote-address" (
                                    ipv4addr
                                  ),
                                  "remote-port" arg,
                                  "transport" (
                                    ("udp" | "grpc")
                                  )
                              )
                          ),
                          "export-profile" arg (
                              c(
                                  "local-address" (
                                    ipv4addr
                                  ),
                                  "local-port" arg,
                                  "dscp" arg,
                                  "forwarding-class" arg,
                                  "reporting-rate" arg,
                                  "payload-size" arg,
                                  "format" (
                                    ("gpb" | "gpb-sdm")
                                  ),
                                  "transport" (
                                    ("udp" | "grpc")
                                  )
                              )
                          ),
                          "sensor" arg (
                              c(
                                  "server-name" arg,
                                  "export-name" arg,
                                  "polling-interval" arg,
                                  "resource" arg,
                                  "resource-filter" arg,
                                  "subscription-id" arg,
                                  "suppress-zeros",
                                  "reporting-rate" arg
                              )
                          )
                      )
                  ),
                  "captive-portal-content-delivery" (
                      c(
                          "rule" (
                            cpcd_rule_object_type
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          ),
                          "profile" arg (
                              c(
                                  c(
                                    "dynamic",
                                    "cpcd-rules" arg,
                                    "cpcd-rule-sets" arg
                                  ),
                                  "ipda-rewrite-options" (
                                      c(
                                          "destination-address" (
                                            ipaddr
                                          ),
                                          "destination-port" arg
                                      )
                                  ),
                                  "http-redirect-options" (
                                      c(
                                          arg
                                      )
                                  )
                              )
                          ),
                          "traceoptions" (
                            cpcd_trace_options_type
                          )
                      )
                  ),
                  "dynamic-flow-capture" (
                      c(
                          "g-max-duplicates" arg,
                          "g-duplicates-dropped-periodicity" arg,
                          "capture-group" (
                            dfc_group_type
                          ),
                          "traceoptions" (
                              c(
                                  "no-remote-trace",
                                  "file" (
                                      c(
                                            arg,
                                          "size" arg,
                                          "files" arg,
                                          "world-readable",
                                          "no-world-readable",
                                          "match" (
                                            regular_expression
                                          )
                                      )
                                  ).as(:oneline)
                              )
                          )
                      )
                  ),
                  "flow-tap" (
                      c(
                          "family" (
                              c(
                                  "inet",
                                  "inet6",
                                  "ccc"
                              )
                          ),
                          "interface" (
                            interface_name
                          ),
                          "tunnel-interface" (
                            interface_name
                          )
                      )
                  ),
                  "radius-flow-tap" (
                      c(
                          "forwarding-class" arg,
                          "source-ipv4-address" (
                            ipv4addr
                          ),
                          "multicast-interception",
                          "interfaces" (
                              c(
                                    tunnel_interface_type
                              )
                          ),
                          c(
                            "routing-instance" arg,
                            "logical-system" arg (
                                c(
                                    "routing-instance" arg
                                )
                            )
                          ),
                          "policy" arg (
                              c(
                                  "inet" (
                                      c(
                                          "drop-policy" (
                                            drop_policy_term
                                          )
                                      )
                                  ),
                                  "inet6" (
                                      c(
                                          "drop-policy" (
                                            drop_policy6_term
                                          )
                                      )
                                  )
                              )
                          ),
                          "snmp" (
                              c(
                                  "notify-targets" arg
                              )
                          )
                      )
                  ),
                  "mobile-flow-tap" (
                      c(
                          "source-interface" (
                              c(
                                    interface_name,
                                  "ipv4-address" (
                                    ipv4addr
                                  )
                              )
                          ).as(:oneline)
                      )
                  ),
                  "flow-monitoring" (
                      c(
                          "version9" (
                              c(
                                  "template" (
                                    version9_template
                                  )
                              )
                          ),
                          "version-ipfix" (
                              c(
                                  "template" (
                                    version_ipfix_template
                                  )
                              )
                          )
                      )
                  ),
                  "jdaf" (
                      c(
                          "routing-instances" arg
                      )
                  ),
                  "rpm" (
                      c(
                          "traceoptions" (
                            rmopd_traceoptions
                          ),
                          "bgp" (
                              c(
                                  "probe-type" (
                                    ("icmp-ping" | "icmp-ping-timestamp" | "icmp6-ping" | "tcp-ping" | "udp-ping" | "udp-ping-timestamp")
                                  ),
                                  "probe-count" arg,
                                  "probe-interval" arg,
                                  "test-interval" arg,
                                  "destination-port" arg,
                                  "history-size" arg,
                                  "moving-average-size" arg,
                                  "data-size" arg,
                                  "data-fill" arg,
                                  "logical-system" (
                                    bgp_logical_system
                                  ),
                                  "routing-instances" (
                                    bgp_routing_instances
                                  )
                              )
                          ),
                          "probe" arg (
                              c(
                                  "test" arg (
                                      c(
                                          "probe-type" (
                                            ("http-get" | "http-metadata-get" | "icmp-ping" | "icmp-ping-timestamp" | "icmp6-ping" | "tcp-ping" | "udp-ping" | "udp-ping-timestamp")
                                          ),
                                          "target" (
                                              c(
                                                  c(
                                                    "address" (
                                                      ipv4addr
                                                    ),
                                                    "inet6-address" (
                                                      ipv6addr
                                                    ),
                                                    "url" arg,
                                                    "inet6-url" arg
                                                  )
                                              )
                                          ).as(:oneline),
                                          "inet6-options" (
                                              c(
                                                  "source-address" (
                                                    ipv6addr
                                                  )
                                              )
                                          ),
                                          "probe-count" arg,
                                          "probe-interval" arg,
                                          "test-interval" arg,
                                          "destination-port" arg,
                                          "source-address" (
                                            ipv4addr
                                          ),
                                          "routing-instance" arg,
                                          "history-size" arg,
                                          "moving-average-size" arg,
                                          "dscp-code-points" arg,
                                          "data-size" arg,
                                          "data-fill" arg,
                                          "thresholds" (
                                              c(
                                                  "successive-loss" arg,
                                                  "total-loss" arg,
                                                  "rtt" arg,
                                                  "jitter-rtt" arg,
                                                  "std-dev-rtt" arg,
                                                  "egress-time" arg,
                                                  "ingress-time" arg,
                                                  "jitter-ingress" arg,
                                                  "jitter-egress" arg,
                                                  "std-dev-ingress" arg,
                                                  "std-dev-egress" arg
                                              )
                                          ),
                                          "traps" (
                                            ("probe-failure" | "test-failure" | "test-completion" | "rtt-exceeded" | "std-dev-exceeded" | "jitter-exceeded" | "ingress-time-exceeded" | "ingress-std-dev-exceeded" | "ingress-jitter-exceeded" | "egress-time-exceeded" | "egress-std-dev-exceeded" | "egress-jitter-exceeded")
                                          ),
                                          "destination-interface" (
                                            interface_name
                                          ),
                                          "hardware-timestamp",
                                          "one-way-hardware-timestamp",
                                          "next-hop" (
                                            ipv4addr
                                          )
                                      )
                                  )
                              )
                          ),
                          "probe-server" (
                              c(
                                  "icmp" (
                                      c(
                                          "destination-interface" (
                                            interface_name
                                          )
                                      )
                                  ),
                                  "tcp" (
                                      c(
                                          "port" arg,
                                          "destination-interface" (
                                            interface_name
                                          )
                                      )
                                  ),
                                  "udp" (
                                      c(
                                          "port" arg,
                                          "destination-interface" (
                                            interface_name
                                          )
                                      )
                                  )
                              )
                          ),
                          "probe-limit" arg,
                          "rfc2544-benchmarking" (
                              c(
                                  "profiles" (
                                      c(
                                          "test-profile" arg (
                                              c(
                                                  "test-type" (
                                                    ("throughput" | "latency" | "frame-loss" | "back-back-frames")
                                                  ),
                                                  "packet-size" arg,
                                                  "bandwidth-kbps" arg,
                                                  "step-percent" arg
                                              )
                                          )
                                      )
                                  ),
                                  "tests" (
                                      c(
                                          "test-name" arg (
                                              c(
                                                  "test-profile" arg,
                                                  "source-mac-address" (
                                                    mac_unicast
                                                  ),
                                                  "destination-mac-address" (
                                                    mac_unicast
                                                  ),
                                                  "ovlan-id" arg,
                                                  "ovlan-priority" arg,
                                                  "ovlan-cfi" arg,
                                                  "outer-tag-protocol-id" arg,
                                                  "ivlan-id" arg,
                                                  "ivlan-priority" arg,
                                                  "ivlan-cfi" arg,
                                                  "vlan-id" arg,
                                                  "vlan-priority" arg,
                                                  "vlan-cfi" arg,
                                                  "service-type" (
                                                    ("eline" | "elan")
                                                  ),
                                                  "in-service",
                                                  "ip-swap",
                                                  "udp-tcp-port-swap",
                                                  "ignore-test-interface-state",
                                                  "check-test-interface-mtu",
                                                  "disable-signature-check",
                                                  "forwarding-class" arg,
                                                  "packet-loss-priority" (
                                                    ("low" | "high" | "medium-high")
                                                  ),
                                                  "dscp-code-points" arg,
                                                  "mode" (
                                                    ("reflect" | "initiate-and-terminate" | "ethernet-loopback")
                                                  ),
                                                  "reflect-mode" (
                                                    ("mac-swap" | "no-mac-swap" | "mac-rewrite")
                                                  ),
                                                  "family" (
                                                    ("inet" | "ccc" | "bridge" | "vpls")
                                                  ),
                                                  "reflect-etype" arg,
                                                  "direction" (
                                                    ("ingress" | "egress")
                                                  ),
                                                  "timestamp-format" (
                                                    ("microseconds" | "nanoseconds")
                                                  ),
                                                  "source-udp-port" arg,
                                                  "destination-udp-port" arg,
                                                  "test-duration" arg,
                                                  "test-iterator-duration" arg,
                                                  "test-finish-wait-duration" arg,
                                                  "transmit-failure-threshold" arg,
                                                  "receive-failure-threshold" arg,
                                                  "test-iterator-pass-threshold" arg,
                                                  "halt-on-prefix-down",
                                                  "skip-arp-iteration",
                                                  "test-interface" (
                                                    interface_name
                                                  ),
                                                  "reflector-port" arg,
                                                  "destination-ipv4-address" (
                                                    ipv4addr
                                                  ),
                                                  "source-ipv4-address" (
                                                    ipv4addr
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "twamp" (
                              c(
                                  "post-cli-implicit-firewall",
                                  "client" (
                                      c(
                                          "control-connection" arg (
                                              c(
                                                  "authentication-mode" (
                                                      c(
                                                          "none"
                                                      )
                                                  ),
                                                  "destination-interface" (
                                                    interface_name
                                                  ),
                                                  "destination-port" arg,
                                                  "history-size" arg,
                                                  "moving-average-size" arg,
                                                  "routing-instance" arg,
                                                  "target-address" (
                                                    ipv4addr
                                                  ),
                                                  "test-count" arg,
                                                  "test-interval" arg,
                                                  "traps" (
                                                      c(
                                                          "test-iteration-done",
                                                          "control-connection-closed"
                                                      )
                                                  ),
                                                  "test-session" arg (
                                                      c(
                                                          "target-address" (
                                                            ipv4addr
                                                          ),
                                                          "data-fill-with-zeros",
                                                          "data-size" arg,
                                                          "dscp-code-points" arg,
                                                          "probe-count" arg,
                                                          "probe-interval" arg,
                                                          "thresholds" (
                                                              c(
                                                                  "successive-loss" arg,
                                                                  "total-loss" arg,
                                                                  "rtt" arg,
                                                                  "jitter-rtt" arg,
                                                                  "std-dev-rtt" arg,
                                                                  "egress-time" arg,
                                                                  "ingress-time" arg,
                                                                  "jitter-ingress" arg,
                                                                  "jitter-egress" arg,
                                                                  "std-dev-ingress" arg,
                                                                  "std-dev-egress" arg
                                                              )
                                                          ),
                                                          "traps" (
                                                              c(
                                                                  "probe-failure",
                                                                  "test-failure",
                                                                  "test-completion",
                                                                  "rtt-exceeded",
                                                                  "std-dev-exceeded",
                                                                  "jitter-exceeded",
                                                                  "ingress-time-exceeded",
                                                                  "ingress-std-dev-exceeded",
                                                                  "ingress-jitter-exceeded",
                                                                  "egress-time-exceeded",
                                                                  "egress-std-dev-exceeded",
                                                                  "egress-jitter-exceeded"
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "server" (
                                      c(
                                          "routing-instance-list" arg (
                                              c(
                                                  "port" arg
                                              )
                                          ),
                                          "authentication-mode" (
                                              c(
                                                  "none",
                                                  "authenticated" (
                                                      c(
                                                          "control-only"
                                                      )
                                                  ).as(:oneline),
                                                  "encrypted" (
                                                      c(
                                                          "control-only"
                                                      )
                                                  ).as(:oneline),
                                                  "control-only-encrypted"
                                              )
                                          ),
                                          "authentication-key-chain" (
                                            twamp_authentication_key_chain
                                          ),
                                          "server-inactivity-timeout" arg,
                                          "max-connection-duration" arg,
                                          "maximum-sessions" arg,
                                          "maximum-sessions-per-connection" arg,
                                          "maximum-connections" arg,
                                          "maximum-connections-per-client" arg,
                                          "port" arg,
                                          "client-list" arg (
                                              c(
                                                  "address" arg
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "video-monitoring" (
                      c(
                          "templates" arg (
                              c(
                                  "interval-duration" arg,
                                  "inactive-timeout" arg,
                                  "rate" (
                                      c(
                                          c(
                                            "media" arg,
                                            "layer3" arg
                                          )
                                      )
                                  ),
                                  "delay-factor" (
                                      c(
                                          "threshold" (
                                              c(
                                                  "info" arg,
                                                  "warning" arg,
                                                  "critical" arg
                                              )
                                          ),
                                            ("disable")
                                      )
                                  ),
                                  "media-loss-rate" (
                                      c(
                                          "threshold" (
                                              c(
                                                  "info" (
                                                      c(
                                                          c(
                                                            "packet-count" (
                                                              unsigned_float
                                                            ),
                                                            "percentage" arg
                                                          )
                                                      )
                                                  ),
                                                  "warning" (
                                                      c(
                                                          c(
                                                            "packet-count" (
                                                              unsigned_float
                                                            ),
                                                            "percentage" arg
                                                          )
                                                      )
                                                  ),
                                                  "critical" (
                                                      c(
                                                          c(
                                                            "packet-count" (
                                                              unsigned_float
                                                            ),
                                                            "percentage" arg
                                                          )
                                                      )
                                                  )
                                              )
                                          ),
                                            ("disable")
                                      )
                                  ),
                                  "media-rate-variation" (
                                      c(
                                          "threshold" (
                                              c(
                                                  "info" arg,
                                                  "warning" arg,
                                                  "critical" arg
                                              )
                                          ),
                                            ("disable")
                                      )
                                  ),
                                  "media-packets-count-in-layer3" arg,
                                  "media-packet-size" arg
                              )
                          ),
                          "interfaces" arg (
                              c(
                                  "family" (
                                      c(
                                          "inet" (
                                              c(
                                                  "input-flows" arg (
                                                      c(
                                                          "source-address" (
                                                            ipv4prefix
                                                          ),
                                                          "destination-address" (
                                                            ipv4prefix
                                                          ),
                                                          "source-port" arg,
                                                          "destination-port" arg,
                                                          "template" arg
                                                      )
                                                  ),
                                                  "output-flows" arg (
                                                      c(
                                                          "source-address" (
                                                            ipv4prefix
                                                          ),
                                                          "destination-address" (
                                                            ipv4prefix
                                                          ),
                                                          "source-port" arg,
                                                          "destination-port" arg,
                                                          "template" arg
                                                      )
                                                  )
                                              )
                                          ),
                                          "mpls" (
                                              c(
                                                  "input-flows" arg (
                                                      c(
                                                          "payload-type" (
                                                            ("ipv4")
                                                          ),
                                                          "source-address" (
                                                            ipprefix
                                                          ),
                                                          "destination-address" (
                                                            ipprefix
                                                          ),
                                                          "source-port" arg,
                                                          "destination-port" arg,
                                                          "template" arg
                                                      )
                                                  ),
                                                  "output-flows" arg (
                                                      c(
                                                          "payload-type" (
                                                            ("ipv4")
                                                          ),
                                                          "source-address" (
                                                            ipprefix
                                                          ),
                                                          "destination-address" (
                                                            ipprefix
                                                          ),
                                                          "source-port" arg,
                                                          "destination-port" arg,
                                                          "template" arg
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "stats-cache-life-time" arg,
                          "errors-cache-life-time" arg,
                          "flow-cache-life-time" arg,
                          "alarms" (
                              c(
                                  "delay-factor" (
                                      c(
                                          "no-syslog-generation",
                                          "generate-snmp-traps",
                                          "storm-control" (
                                              c(
                                                  "count" arg,
                                                  "interval" arg
                                              )
                                          ),
                                          "alarm-mode" (
                                              c(
                                                  "mdi-records-count" arg,
                                                  c(
                                                    "immediate",
                                                    "average"
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "media-rate-variation" (
                                      c(
                                          "no-syslog-generation",
                                          "generate-snmp-traps",
                                          "storm-control" (
                                              c(
                                                  "count" arg,
                                                  "interval" arg
                                              )
                                          ),
                                          "alarm-mode" (
                                              c(
                                                  "mdi-records-count" arg,
                                                  c(
                                                    "immediate",
                                                    "average"
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "media-loss-rate" (
                                      c(
                                          "no-syslog-generation",
                                          "generate-snmp-traps",
                                          "storm-control" (
                                              c(
                                                  "count" arg,
                                                  "interval" arg
                                              )
                                          ),
                                          "alarm-mode" (
                                              c(
                                                  "mdi-records-count" arg,
                                                  c(
                                                    "immediate",
                                                    "average"
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "flow-insert" (
                                      c(
                                          "no-syslog-generation",
                                          "generate-snmp-traps",
                                          "storm-control" (
                                              c(
                                                  "count" arg,
                                                  "interval" arg
                                              )
                                          )
                                      )
                                  ),
                                  "flow-delete" (
                                      c(
                                          "no-syslog-generation",
                                          "generate-snmp-traps",
                                          "storm-control" (
                                              c(
                                                  "count" arg,
                                                  "interval" arg
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "app-engine" (
                      c(
                          "security",
                          "monitor-cpu" (
                            monitor_threshold
                          ),
                          "monitor-memory" (
                            monitor_threshold
                          ),
                          "monitor-storage" (
                            monitor_threshold
                          ),
                          "default-compute-node-package" arg,
                          "compute-cluster" arg (
                              c(
                                  "local-management" (
                                      c(
                                          "routing-instance" (
                                              s(
                                                      arg,
                                                c(
                                                  "family" (
                                                      c(
                                                          "inet" (
                                                              c(
                                                                  "address" (
                                                                    ipv4addr
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                                )
                                              )
                                          ),
                                          "family" (
                                              c(
                                                  "inet" (
                                                      c(
                                                          "address" (
                                                            ipv4addr
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "monitor-cpu" (
                                    monitor_threshold
                                  ),
                                  "monitor-memory" (
                                    monitor_threshold
                                  ),
                                  "monitor-storage" (
                                    monitor_threshold
                                  ),
                                  "compute-node" arg (
                                      c(
                                          "monitor-cpu" (
                                            monitor_threshold
                                          ),
                                          "monitor-memory" (
                                            monitor_threshold
                                          ),
                                          "monitor-storage" (
                                            monitor_threshold
                                          ),
                                          c(
                                            "mac-address" (
                                              mac_addr
                                            ),
                                            "fpc" arg,
                                            "hypervisor"
                                          ),
                                          "package" arg,
                                          "routing-options" (
                                              c(
                                                  "static" (
                                                      c(
                                                          "route" arg (
                                                              c(
                                                                  "next-hop" (
                                                                    ipv4addr
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  ),
                                                  "rib" arg (
                                                      c(
                                                          "static" (
                                                              c(
                                                                  "route" arg (
                                                                      c(
                                                                          "next-hop" (
                                                                            ipv4addr
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          ),
                                          "interfaces" (
                                              c(
                                                  "ethernet" arg (
                                                      c(
                                                          "management",
                                                          "family" (
                                                            family
                                                          ),
                                                          "enable-passthrough",
                                                          "mtu" arg,
                                                          "ether-options" (
                                                              c(
                                                                  c(
                                                                    "ieee-802-3ad" arg
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  ),
                                                  "bridge" arg (
                                                      c(
                                                          "management",
                                                          "family" (
                                                            family
                                                          ),
                                                          "interface" arg,
                                                          "mtu" arg
                                                      )
                                                  ),
                                                  "aggregate" arg (
                                                      c(
                                                          "management",
                                                          "family" (
                                                            family
                                                          ),
                                                          "mtu" arg,
                                                          "aggregated-ether-options" (
                                                              c(
                                                                  "hash-policy" (
                                                                    ("layer-2" | "layer-3-and-4" | "layer-2-and-3")
                                                                  ),
                                                                  "miimon" arg
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          ),
                                          "syslog" (("any" | "authorization" | "privileged" | "cron" | "daemon" | "kernel" | "syslog" | "user" | "uucp" | "local0" | "local1" | "local2" | "local3" | "local4" | "local5" | "local6" | "local7")) (
                                              c(
                                                  c(
                                                    "any",
                                                    "emergency",
                                                    "alert",
                                                    "critical",
                                                    "error",
                                                    "warning",
                                                    "notice",
                                                    "info",
                                                    "debug"
                                                  )
                                              )
                                          ).as(:oneline)
                                      )
                                  )
                              )
                          ),
                          "virtual-machines" (
                              c(
                                  "instance" arg (
                                      c(
                                          "cpu" arg,
                                          "memory" arg,
                                          "management-interface" arg,
                                          "package" arg,
                                          "local-management" (
                                              c(
                                                  "routing-instance" (
                                                      s(
                                                              arg,
                                                        c(
                                                          "family" (
                                                              c(
                                                                  "inet" (
                                                                      c(
                                                                          "address" (
                                                                            ipv4addr
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                        )
                                                      )
                                                  ),
                                                  "family" (
                                                      c(
                                                          "inet" (
                                                              c(
                                                                  "address" (
                                                                    ipv4addr
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          ),
                                          "compute-cluster" arg (
                                              c(
                                                  "compute-node" arg
                                              )
                                          ),
                                          "interface" arg (
                                              c(
                                                  "hw-model" (
                                                    ("e1000g" | "virtio")
                                                  ),
                                                  "host-interface" arg,
                                                  "bridge" arg,
                                                  "mtu" arg,
                                                  "family" (
                                                      c(
                                                          "inet" (
                                                              c(
                                                                  "address" arg (
                                                                      c(
                                                                          "primary"
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          ),
                                          "routing-options" (
                                              c(
                                                  "static" (
                                                      c(
                                                          "route" arg (
                                                              c(
                                                                  "next-hop" (
                                                                    ipv4addr
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  ),
                                                  "rib" arg (
                                                      c(
                                                          "static" (
                                                              c(
                                                                  "route" arg (
                                                                      c(
                                                                          "next-hop" (
                                                                            ipv4addr
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          ),
                                          "secondary-disk" ("hdb" | "hdc" | "hdd") (
                                              c(
                                                  "size" arg
                                              )
                                          ).as(:oneline)
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "unified-access-control" (
                      c(
                          "infranet-controller" arg (
                              c(
                                  "address" (
                                    ipv4addr
                                  ),
                                  "port" arg,
                                  "interface" (
                                    interface_name
                                  ),
                                  "password" arg,
                                  "ca-profile" arg,
                                  "server-certificate-subject" arg
                              )
                          ),
                          "certificate-verification" (
                            ("warning" | "required" | "optional")
                          ),
                          "timeout" arg,
                          "interval" arg,
                          "timeout-action" (
                            ("close" | "no-change" | "open")
                          ),
                          "test-only-mode",
                          "traceoptions" (
                              c(
                                  "no-remote-trace",
                                  "file" (
                                      c(
                                            arg,
                                          "size" arg,
                                          "files" arg,
                                          "world-readable",
                                          "no-world-readable",
                                          "match" (
                                            regular_expression
                                          )
                                      )
                                  ).as(:oneline),
                                  "flag" (("all" | "ipc" | "config" | "connect")).as(:oneline)
                              )
                          ),
                          "captive-portal" arg (
                              c(
                                  "redirect-traffic" (
                                    ("unauthenticated" | "all")
                                  ),
                                  "redirect-url" arg
                              )
                          )
                      )
                  ),
                  "flow-collector" (
                      c(
                          "analyzer-address" (
                            ipv4addr
                          ),
                          "analyzer-id" arg,
                          "retry" arg,
                          "retry-delay" arg,
                          "destinations" (
                            collector_destinations_type
                          ),
                          "file-specification" (
                            file_specification_type
                          ),
                          "interface-map" (
                            interface_map_type
                          ),
                          "transfer-log-archive" (
                            collector_transfer_log_archive_type
                          )
                      )
                  ),
                  "captive-portal" (
                    juniper_services_captive_portal
                  ),
                  "logging" (
                    juniper_pic_services_logging_options
                  ),
                  "application-identification" (
                      c(
                          "enable-heuristics",
                          "enable-performance-mode" (
                              c(
                                  "max-packet-threshold" arg
                              )
                          ),
                          "download" (
                              c(
                                  "url" arg,
                                  "ignore-server-validation",
                                  "automatic" (
                                      c(
                                          "start-time" arg,
                                          "interval" arg
                                      )
                                  )
                              )
                          ),
                          "statistics" (
                              c(
                                  "interval" arg
                              )
                          ),
                          "nested-application-settings" (
                              c(
                                  "no-nested-application",
                                  "no-application-system-cache"
                              )
                          ),
                          "no-application-identification",
                          "no-signature-based",
                          "no-protocol-based",
                          "signature-method-all-ports",
                          "no-clear-application-system-cache",
                          "no-application-system-cache",
                          "max-sessions" arg,
                          "application-system-cache-timeout" arg,
                          "max-checked-bytes" arg,
                          "application" arg (
                              c(
                                  "type" arg,
                                  "index" arg,
                                  "tags" arg (
                                      c(
                                          arg
                                      )
                                  ),
                                  "session-timeout" (
                                    ("0" | "30" | "60" | "1800" | "3600" | "43200" | "86400" | "2592000")
                                  ),
                                  "idle-timeout" (
                                    ("0" | "5" | "15" | "30" | "60" | "1800" | "3600")
                                  ),
                                  "type-of-service" (
                                      c(
                                          "minimize-delay",
                                          "maximize-throughput",
                                          "maximize-reliability",
                                          "minimize-monetary-cost"
                                      )
                                  ),
                                  "disable",
                                  "cacheable",
                                  "description" arg,
                                  "priority" (
                                    ("high" | "low")
                                  ),
                                  "order" arg,
                                  "maximum-transactions" arg,
                                  "alt-name" arg,
                                  "compatibility" arg,
                                  "port-mapping" (
                                      c(
                                          "icmp" (
                                              c(
                                                  "type" arg,
                                                  "code" arg
                                              )
                                          ),
                                          "protocol" arg,
                                          "port-range" (
                                              c(
                                                  "tcp" arg,
                                                  "udp" arg
                                              )
                                          ),
                                          "disable"
                                      )
                                  ),
                                  "icmp-mapping" (
                                      c(
                                          "type" arg,
                                          "code" arg,
                                          "order" arg,
                                          "order-priority" (
                                            ("high" | "low")
                                          )
                                      )
                                  ),
                                  "ip-protocol-mapping" (
                                      c(
                                          "protocol" arg,
                                          "order" arg,
                                          "order-priority" (
                                            ("high" | "low")
                                          )
                                      )
                                  ),
                                  "address-mapping" arg (
                                      c(
                                          "filter" (
                                              c(
                                                  "ip" (
                                                    ipprefix
                                                  ),
                                                  "port-range" (
                                                      c(
                                                          "tcp" arg,
                                                          "udp" arg
                                                      )
                                                  )
                                              )
                                          ),
                                          "source" (
                                              c(
                                                  "ip" (
                                                    ipprefix
                                                  ),
                                                  "wildcard-address" (
                                                      c(
                                                            ipaddr,
                                                          "wildcard-mask" (
                                                            ipaddr
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "port-range" (
                                                      c(
                                                          "tcp" arg,
                                                          "udp" arg
                                                      )
                                                  )
                                              )
                                          ),
                                          "destination" (
                                              c(
                                                  "ip" (
                                                    ipprefix
                                                  ),
                                                  "wildcard-address" (
                                                      c(
                                                            ipaddr,
                                                          "wildcard-mask" (
                                                            ipaddr
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "port-range" (
                                                      c(
                                                          "tcp" arg,
                                                          "udp" arg
                                                      )
                                                  )
                                              )
                                          ),
                                          "order" arg,
                                          "order-priority" (
                                            ("high" | "low")
                                          )
                                      )
                                  ),
                                  "over" arg (
                                      c(
                                          "protocol" (
                                            ("http" | "ssl" | "udp" | "tcp")
                                          ),
                                          "chain-order",
                                          "order-priority" (
                                            ("high" | "low")
                                          ),
                                          "order" arg,
                                          "port-range" (
                                              c(
                                                  "tcp" arg,
                                                  "udp" arg
                                              )
                                          ),
                                          "member" arg (
                                              c(
                                                  "context" (
                                                    ("http-url-parsed" | "http-url-parsed-param-parsed" | "http-header-host" | "http-header-location" | "http-header-content-type" | "http-get-url-parsed-param-parsed" | "http-post-url-parsed-param-parsed" | "http-header-cookie" | "http-header-user-agent" | "http-post-variable-parsed" | "ssl-server-name" | "stream")
                                                  ),
                                                  "pattern" arg,
                                                  "direction" (
                                                    ("client-to-server" | "server-to-client" | "any")
                                                  ),
                                                  "check-bytes" arg
                                              )
                                          ),
                                          "signature" arg (
                                              c(
                                                  "port-range" arg,
                                                  "member" arg (
                                                      c(
                                                          "context" arg,
                                                          "pattern" arg,
                                                          "direction" (
                                                            ("client-to-server" | "server-to-client" | "any")
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "nested-application" arg (
                              c(
                                  "type" arg,
                                  "index" arg,
                                  "protocol" arg,
                                  "signature" arg (
                                      c(
                                          "member" arg (
                                              c(
                                                  "context" (
                                                    ("http-url-parsed" | "http-url-parsed-param-parsed" | "http-header-host" | "http-header-location" | "http-header-content-type" | "http-get-url-parsed-param-parsed" | "http-post-url-parsed-param-parsed" | "http-header-cookie" | "http-header-user-agent" | "http-post-variable-parsed" | "ssl-server-name" | "stream")
                                                  ),
                                                  "pattern" arg,
                                                  "direction" (
                                                    ("client-to-server" | "server-to-client" | "any")
                                                  ),
                                                  "check-bytes" arg
                                              )
                                          ),
                                          "chain-order",
                                          "maximum-transactions" arg,
                                          "order" arg,
                                          "insert-before" (
                                              c(
                                                  arg
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "application-group" arg (
                              c(
                                  "application-groups" arg,
                                  "applications" arg,
                                  "disable"
                              )
                          ),
                          "rule" arg (
                              c(
                                  "application-name" arg,
                                  "address" arg (
                                      c(
                                          "source" (
                                              c(
                                                  "ip" (
                                                    ipv4prefix
                                                  ),
                                                  "port-range" (
                                                      c(
                                                          "tcp" arg,
                                                          "udp" arg
                                                      )
                                                  )
                                              )
                                          ),
                                          "destination" (
                                              c(
                                                  "ip" (
                                                    ipv4prefix
                                                  ),
                                                  "port-range" (
                                                      c(
                                                          "tcp" arg,
                                                          "udp" arg
                                                      )
                                                  )
                                              )
                                          ),
                                          "order" arg
                                      )
                                  )
                              )
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          ),
                          "profile" arg (
                              c(
                                  "rule-set" arg
                              )
                          ),
                          "traceoptions" (
                              c(
                                  "no-remote-trace",
                                  "file" (
                                      c(
                                            arg,
                                          "size" arg,
                                          "files" arg,
                                          "world-readable",
                                          "no-world-readable",
                                          "match" (
                                            regular_expression
                                          )
                                      )
                                  ).as(:oneline),
                                  "flag" (("all")).as(:oneline),
                                  "level" (
                                    ("error" | "warning" | "notice" | "info" | "verbose" | "all")
                                  )
                              )
                          )
                      )
                  ),
                  "service-set" arg (
                      c(
                          "syslog" (
                            service_set_syslog_object
                          ),
                          "max-flows" arg,
                          "hosted-service-identifier" arg,
                          "max-session-setup-rate" arg,
                          "max-drop-flows" (
                              c(
                                  "ingress" arg,
                                  "egress" arg
                              )
                          ),
                          "snmp-trap-thresholds" (
                              c(
                                  "flow" (
                                      c(
                                          "low" arg,
                                          "high" arg
                                      )
                                  ).as(:oneline),
                                  "nat-address-port" (
                                      c(
                                          "low" arg,
                                          "high" arg
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "tcp-mss" arg,
                          "softwire-options" (
                              c(
                                  "dslite-ipv6-prefix-length" (
                                    ("56" | "64" | "96" | "128")
                                  )
                              )
                          ),
                          "nat-options" (
                              c(
                                  "stateful-nat64" (
                                      c(
                                          "clear-dont-fragment-bit",
                                          "ipv6-mtu" arg,
                                          "disable-h323-ras"
                                      )
                                  ),
                                  "nptv6" (
                                      c(
                                          "icmpv6-error-messages"
                                      )
                                  ),
                                  "land-attack-check" (
                                    ("ip-only" | "ip-port")
                                  ),
                                  "max-sessions-per-subscriber" arg,
                                  "snmp-value-match-msmic"
                              )
                          ),
                          "service-set-options" (
                              c(
                                  "tcp-non-syn" (
                                    ("drop-flow" | "drop-flow-send-rst")
                                  ),
                                  "tcp-fast-open" (
                                    ("disabled" | "drop")
                                  ),
                                  "bypass-traffic-on-pic-failure",
                                  "bypass-traffic-on-exceeding-flow-limits",
                                  "enable-asymmetric-traffic-processing",
                                  "subscriber-awareness",
                                  "header-integrity-check" (
                                      c(
                                          "enable-all"
                                      )
                                  ),
                                  "enable-change-on-ams-redistribution",
                                  "routing-engine-services"
                              )
                          ),
                          "replicate-services" (
                              c(
                                  "replication-threshold" arg,
                                  "disable-replication-capability"
                              )
                          ),
                          "allow-multicast",
                          c(
                            "softwire-rules" arg,
                            "softwire-rule-sets" arg
                          ),
                          c(
                            "stateful-firewall-rules" arg,
                            "stateful-firewall-rule-sets" arg
                          ),
                          c(
                            "pcp-rules" arg,
                            "pcp-rule-sets" arg
                          ),
                          c(
                            "nat-rules" arg,
                            "nat-rule-sets" arg
                          ),
                          c(
                            "ip-reassembly-rules" arg
                          ),
                          c(
                            "ids-rules" arg,
                            "ids-rule-sets" arg
                          ),
                          c(
                            "cos-rules" arg,
                            "cos-rule-sets" arg
                          ),
                          c(
                            "aacl-rules" arg,
                            "aacl-rule-sets" arg
                          ),
                          "aacl-dyn-rules" arg,
                          c(
                            "ptsp-rules" arg,
                            "ptsp-rule-sets" arg
                          ),
                          c(
                            "pgcp-rules" arg,
                            "pgcp-rule-sets" arg
                          ),
                          "jflow-rules" (
                              c(
                                  "sampling" (
                                      c(
                                          "instance" arg
                                      )
                                  )
                              )
                          ),
                          c(
                            "application-identification-profile" arg
                          ),
                          "pcef-profile" arg,
                          "lrf-profile" arg,
                          "hcm-profile" arg,
                          "url-filter-profile" arg,
                          c(
                            "hcm-url-rules" arg,
                            "hcm-url-rule-sets" arg
                          ),
                          c(
                            "tag-rules" arg,
                            "tag-rule-sets" arg
                          ),
                          c(
                            "idp-profile" arg
                          ),
                          c(
                            "captive-portal-content-delivery-profile" arg
                          ),
                          c(
                            "policy-decision-statistics-profile" (
                                c(
                                      arg
                                )
                            )
                          ),
                          c(
                            "interface-service" (
                                c(
                                    "service-interface" (
                                      interface_unit
                                    ),
                                    "load-balancing-options" (
                                        c(
                                            "hash-keys" (
                                                c(
                                                    "resource-triggered",
                                                    "ingress-key" (
                                                          (("source-ip" | "destination-ip" | "protocol" | "iif"))
                                                    ),
                                                    "egress-key" (
                                                          (("source-ip" | "destination-ip" | "protocol" | "oif"))
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            "sampling-service" (
                                c(
                                    "service-interface" (
                                      interface_unit
                                    )
                                )
                            ),
                            "next-hop-service" (
                                c(
                                    "inside-service-interface" (
                                      interface_unit
                                    ),
                                    "outside-service-interface" (
                                      interface_unit
                                    ),
                                    "outside-service-interface-type" (
                                      ("local")
                                    ),
                                    "service-interface-pool" arg
                                )
                            )
                          ),
                          "extension-service" arg,
                          "service-order" (
                              c(
                                  "forward-flow" arg,
                                  "reverse-flow" arg
                              )
                          ),
                          "subscriber-profile" arg,
                          "jflow-log" (
                              c(
                                  "template-profile" arg
                              )
                          ),
                          "ipsec-vpn-options" (
                            service_set_ipsec_vpn_options_object
                          ),
                          c(
                            "ipsec-vpn-rules" arg,
                            "ipsec-vpn-rule-sets" arg
                          ),
                          "ipsec-group-vpn" arg,
                          "redundancy-set-id" arg
                      )
                  ),
                  "ipsec-vpn" (
                      c(
                          "rule" (
                            ipsec_vpn_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          ),
                          "ipsec" (
                            services_ipsec
                          ),
                          "ike" (
                            services_ike
                          ),
                          "traceoptions" (
                            ipsec_services_traceoptions
                          ),
                          "no-ipsec-tunnel-in-traceroute",
                          "establish-tunnels" (
                            ("immediately" | "on-traffic")
                          ),
                          "clear-ike-sas-on-pic-restart",
                          "clear-ipsec-sas-on-pic-restart",
                          "disable-natt"
                      )
                  ),
                  "lrf" (
                      c(
                          "profile" (
                            lrf_profile_object
                          )
                      )
                  ),
                  "pcef" (
                    services_pcef
                  ),
                  "ssl" (
                      c(
                          "traceoptions" (
                            ssl_traceoptions
                          ),
                          "termination" (
                            ssl_termination_config
                          ),
                          "initiation" (
                            ssl_initiation_config
                          ),
                          "proxy" (
                            ssl_proxy_config
                          )
                      )
                  ),
                  "stateful-firewall" (
                      c(
                          "rule" (
                            sfw_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "ip-reassembly" (
                      c(
                          "profile" (
                            ipr_profile_object
                          ),
                          "rule" (
                            ipr_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "softwire" (
                      c(
                          "ipv6-multicast-interfaces" ("all" | "interface-name"),
                          "softwire-concentrator" (
                              c(
                                  "ds-lite" (
                                    dslite_object
                                  ),
                                  "v6rd" (
                                    v6rd_object
                                  )
                              )
                          ),
                          "rule" (
                            sw_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "aacl" (
                      c(
                          "rule" (
                            aacl_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          ),
                          "aacl-dyn-rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "ptsp" (
                      c(
                          "rule" (
                            ptsp_rule_object
                          ),
                          "forward-rule" (
                            ptsp_forward_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "hcm" (
                      c(
                          "url-rule" (
                            hcm_url_rule_object
                          ),
                          "tag-rule" (
                            hcm_tag_rule_object
                          ),
                          "url-list" (
                            hcm_url_list_object
                          ),
                          "tag-attribute" (
                                ("msisdn" | "imsi" | "apn" | "imei" | "ipv4addr" | "ipv6addr" | "ggsnipv4" | "ggsnipv6" | "radiusclass")
                          ),
                          "url-rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          ),
                          "tag-rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          ),
                          "profile" arg (
                              c(
                                  "tag-rule" (
                                      c(
                                          arg
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "cos" (
                      c(
                          "application-profile" (
                            cos_application_profile_object
                          ),
                          "rule" (
                            cos_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "pgcp" (
                      c(
                          "traceoptions" (
                              c(
                                  "flag" (
                                      c(
                                          "default" (
                                            ("trace" | "debug" | "info" | "warning" | "error")
                                          ),
                                          "h248-stack" (
                                              c(
                                                  "default" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "control-association" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "media-gateway" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "messages"
                                              )
                                          ),
                                          "bgf-core" (
                                              c(
                                                  "default" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "firewall" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "gate-logic" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "policy" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "pic-broker" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "statistics" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "common" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  )
                                              )
                                          ),
                                          "sbc-utils" (
                                              c(
                                                  "default" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "common" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "configuration" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "device-monitor" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "ipc" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "memory-management" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "messaging" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  ),
                                                  "user-interface" (
                                                    ("trace" | "debug" | "info" | "warning" | "error")
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "file" (
                                      c(
                                            arg,
                                          "size" arg,
                                          "files" arg,
                                          "world-readable",
                                          "no-world-readable",
                                          "match" (
                                            regular_expression
                                          )
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "media-service" (
                            pgcp_media_service_object
                          ),
                          "virtual-interface" (
                            pgcp_virtual_interface_object
                          ),
                          "gateway" (
                            pgcp_gateway_object
                          ),
                          "rule" (
                            pgcp_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          ),
                          "session-mirroring" (
                            pgcp_session_mirroring_object
                          ),
                          "notification-rate-limit" arg
                      )
                  ),
                  "border-signaling-gateway" (
                      c(
                          "gateway" (
                            gateway_type
                          )
                      )
                  ),
                  "ids" (
                      c(
                          "rule" (
                            ids_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "pcp" (
                      c(
                          "server" (
                            pcp_server_object
                          ),
                          "rule" (
                            pcp_rule_object
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "nat" (
                      c(
                          "pool" (
                            nat_pool_object
                          ),
                          "ipv6-multicast-interfaces" ("all" | "interface-name") (
                              c(
                                  "disable"
                              )
                          ),
                          "allow-overlapping-nat-pools",
                          "rule" (
                            nat_rule_object
                          ),
                          "port-forwarding" (
                            pf_mapping
                          ),
                          "rule-set" arg (
                              c(
                                  "rule" arg
                              )
                          )
                      )
                  ),
                  "l2tp" (
                      c(
                          "tunnel-group" (
                            l2tp_tunnel_group_object
                          ),
                          "ip-reassembly" (
                              c(
                                  "service-set" arg
                              )
                          ),
                          "traceoptions" (
                              c(
                                  "no-remote-trace",
                                  "file" (
                                      c(
                                            arg,
                                          "size" arg,
                                          "files" arg,
                                          "world-readable",
                                          "no-world-readable",
                                          "match" (
                                            regular_expression
                                          )
                                      )
                                  ).as(:oneline),
                                  "level" (
                                    ("error" | "warning" | "notice" | "info" | "verbose" | "all")
                                  ),
                                  "flag" (("gres" | "init" | "events" | "memory" | "message" | "packet-error" | "parse" | "receive-packets" | "session-db" | "states" | "timer" | "transmit-packets" | "routing-socket" | "routing-process" | "protocol" | "configuration" | "ipc-tx" | "ipc-rx" | "general" | "tunnel" | "stats" | "authentication" | "all")).as(:oneline),
                                  "debug-level" (
                                    ("error" | "detail" | "packet-dump")
                                  ),
                                  "filter" (
                                      c(
                                          "protocol" (("ppp" | "l2tp" | "radius" | "udp")).as(:oneline),
                                          "user-name" arg,
                                          "user" (
                                              c(
                                                    arg
                                              )
                                          )
                                      )
                                  ),
                                  "interfaces" (
                                    l2tp_interface_traceoptions
                                  )
                              )
                          ),
                          "weighted-load-balancing",
                          "destination-equal-load-balancing",
                          "drain",
                          "failover-within-preference",
                          "disable-calling-number-avp",
                          "disable-failover-protocol",
                          "rx-connect-speed-when-equal",
                          "tx-connect-speed-method" (
                            ("none" | "static" | "ancp" | "pppoe-ia-tag" | "service-profile")
                          ),
                          "maximum-sessions" arg,
                          "tunnel" (
                              c(
                                  "name" arg (
                                      c(
                                          "address" arg (
                                              c(
                                                  "routing-instance" arg (
                                                      c(
                                                          "drain"
                                                      )
                                                  ).as(:oneline),
                                                  "drain"
                                              )
                                          ).as(:oneline),
                                          "drain"
                                      )
                                  ).as(:oneline),
                                  "assignment-id-format" (
                                    ("assignment-id" | "client-server-id")
                                  ),
                                  "retransmission-count-established" arg,
                                  "retransmission-count-not-established" arg,
                                  "nas-port-method" (
                                    ("cisco-avp")
                                  ),
                                  "minimum-retransmission-timeout" (
                                    ("1" | "2" | "4" | "8" | "16")
                                  ),
                                  "idle-timeout" arg,
                                  "rx-window-size" arg,
                                  "tx-address-change" (
                                      c(
                                          "accept",
                                          "ignore",
                                          "ignore-ip-address",
                                          "ignore-udp-port",
                                          "reject",
                                          "reject-ip-address",
                                          "reject-udp-port"
                                      )
                                  ),
                                  "maximum-sessions" arg,
                                  "failover-resync" (
                                    ("silent-failover" | "failover-protocol")
                                  )
                              )
                          ),
                          "destruct-timeout" arg,
                          "tunnel-switch-profile" arg,
                          "destination" (
                            l2tp_destination_object
                          ),
                          "access-line-information" (
                            l2tp_access_line_object
                          ),
                          "session-limit-group" arg (
                              c(
                                  "maximum-sessions" arg
                              )
                          ),
                          "enable-ipv6-services-for-lac",
                          "enable-snmp-tunnel-statistics"
                      )
                  ),
                  "adaptive-services-pics" (
                      c(
                          "traceoptions" (
                              c(
                                  "no-remote-trace",
                                  "file" (
                                      c(
                                            arg,
                                          "size" arg,
                                          "files" arg,
                                          "world-readable",
                                          "no-world-readable",
                                          "match" (
                                            regular_expression
                                          )
                                      )
                                  ).as(:oneline),
                                  "flag" (("routing-socket" | "routing-protocol" | "service-identification" | "configuration" | "ipc" | "kernel-object" | "snmp" | "all")).as(:oneline)
                              )
                          )
                      )
                  ),
                  "license-management" (
                      c(
                          "license-server" (
                              c(
                                  "ip-address" (
                                    ipv4addr
                                  ),
                                  "log-interval" arg,
                                  "services" (
                                    ("jflow" | "cgnat" | "firewall")
                                  )
                              )
                          )
                      )
                  ),
                  "soft-gre" (
                      c(
                            soft_gre_tunnel_group_object
                      )
                  ),
                  "service-interface-pools" (
                      c(
                          "pool" (
                            service_interface_pool_object
                          )
                      )
                  ),
                  "hosted-services" (
                      c(
                          "client-profile" arg (
                              c(
                                  "transport-type" (
                                    ("GRE" | "UDP" | "TCP")
                                  ),
                                  "client-address" (
                                    ipv4addr
                                  ),
                                  "hosted-service-identifier" arg
                              )
                          ),
                          "server-profile" arg (
                              c(
                                  "transport-type" (
                                    ("GRE" | "UDP" | "TCP")
                                  ),
                                  "server-address" (
                                    ipv4addr
                                  ),
                                  "client-address" (
                                    ipv4addr
                                  ),
                                  "hosted-service-identifier" arg
                              )
                          )
                      )
                  ),
                  "jflow-log" (
                      c(
                          "collector" arg (
                              c(
                                  "destination-address" arg,
                                  "destination-port" arg,
                                  "source-ip" (
                                    ipv4addr
                                  )
                              )
                          ),
                          "collector-group" arg (
                              c(
                                  "collector" arg
                              )
                          ),
                          "template-profile" arg (
                              c(
                                  "collector" arg,
                                  "collector-group" arg,
                                  "template-type" (
                                    ("nat")
                                  ),
                                  "version" (
                                    ("v9" | "ipfix")
                                  ),
                                  "refresh-rate" (
                                      c(
                                          "packets" arg,
                                          "seconds" arg
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "service-device-pools" (
                      c(
                          "pool" (
                            service_device_pool_object
                          )
                      )
                  ),
                  "redundancy-set" (
                      c(
                          "traceoptions" (
                            srd_traceoptions_object
                          ),
                            srd_rs_id_object
                      )
                  ),
                  "traffic-load-balance" (
                    tdir_service_load_balance_object
                  ),
                  "network-monitoring" (
                    tdir_netmon_object
                  ),
                  "url-filter" (
                      c(
                          "profile" (
                            urlf_profile_object
                          ),
                          "traceoptions" (
                            urlf_traceoptions_object
                          )
                      )
                  )
              )
          ),
          "access-profile" (
              c(
                  arg
              )
          ).as(:oneline),
          "security" (
              c(
                  "alarms" (
                      c(
                          "audible" (
                              c(
                                  "continuous"
                              )
                          ),
                          "potential-violation" (
                              c(
                                  "authentication" arg,
                                  "cryptographic-self-test",
                                  "decryption-failures",
                                  "encryption-failures",
                                  "ike-phase1-failures",
                                  "ike-phase2-failures",
                                  "key-generation-self-test",
                                  "non-cryptographic-self-test",
                                  "policy",
                                  "replay-attacks" (
                                      c(
                                          "threshold" arg
                                      )
                                  ),
                                  "security-log-percent-full" arg,
                                  "idp"
                              )
                          )
                      )
                  ),
                  "log" (
                      c(
                          "exclude" arg (
                              c(
                                  "destination-address" (
                                    ipaddr
                                  ),
                                  "destination-port" arg,
                                  "event-id" arg,
                                  "failure",
                                  "interface-name" arg,
                                  "policy-name" arg,
                                  "process" arg,
                                  "protocol" arg,
                                  "source-address" (
                                    ipaddr
                                  ),
                                  "source-port" arg,
                                  "success",
                                  "username" arg
                              )
                          ),
                          "limit" arg,
                          "cache" (
                              c(
                                  "exclude" arg (
                                      c(
                                          "destination-address" (
                                            ipaddr
                                          ),
                                          "destination-port" arg,
                                          "event-id" arg,
                                          "failure",
                                          "interface-name" arg,
                                          "policy-name" arg,
                                          "process" arg,
                                          "protocol" arg,
                                          "source-address" (
                                            ipaddr
                                          ),
                                          "source-port" arg,
                                          "success",
                                          "username" arg
                                      )
                                  ),
                                  "limit" arg
                              )
                          )
                      )
                  ),
                  "certificates" (
                      c(
                          "local" (
                            certificate_object
                          ),
                          "path-length" arg,
                          "maximum-certificates" arg,
                          "cache-size" arg,
                          "cache-timeout-negative" arg,
                          "enrollment-retry" arg,
                          "certification-authority" arg (
                              c(
                                  "ca-name" arg,
                                  "file" arg,
                                  "crl" arg,
                                  "enrollment-url" arg,
                                  "ldap-url" arg,
                                  "encoding" (
                                    ("binary" | "pem")
                                  )
                              )
                          )
                      )
                  ),
                  "ssh-known-hosts" (
                      c(
                          "host" arg (
                              c(
                                  "rsa1-key" arg,
                                  "rsa-key" arg,
                                  "dsa-key" arg,
                                  "ecdsa-key" arg,
                                  "ecdsa-sha2-nistp256-key" arg,
                                  "ecdsa-sha2-nistp384-key" arg,
                                  "ecdsa-sha2-nistp521-key" arg,
                                  "ed25519-key" arg
                              )
                          )
                      )
                  ),
                  "key-protection",
                  "pki" (
                    security_pki
                  ),
                  "group-vpn" (
                    security_group_vpn
                  ),
                  "traceoptions" (
                    security_traceoptions
                  ),
                  "ipsec" (
                    security_ipsec
                  ),
                  "ike" (
                    security_ike
                  ),
                  "authentication-key-chains" (
                    security_authentication_key_chains
                  ),
                  "idp" (
                      c(
                          "idp-policy" (
                            idp_policy_type
                          ),
                          "active-policy" arg,
                          "custom-attack" (
                            custom_attack_type
                          ),
                          "custom-attack-group" (
                            custom_attack_group_type
                          ),
                          "dynamic-attack-group" (
                            dynamic_attack_group_type
                          ),
                          "traceoptions" (
                            idpd_traceoptions_type
                          ),
                          "security-package" (
                              c(
                                  "url" arg,
                                  "source-address" (
                                    ipv4addr
                                  ),
                                  "install" (
                                      c(
                                          "ignore-version-check"
                                      )
                                  ),
                                  "automatic" (
                                      c(
                                          "start-time" (
                                            time
                                          ),
                                          "interval" arg,
                                          "download-timeout" arg,
                                            ("enable")
                                      )
                                  )
                              )
                          ),
                          "sensor-configuration" (
                              c(
                                  "log" (
                                      c(
                                          "cache-size" arg,
                                          "suppression" (
                                              c(
                                                    ("disable"),
                                                  "include-destination-address",
                                                  "no-include-destination-address",
                                                  "start-log" arg,
                                                  "max-logs-operate" arg,
                                                  "max-time-report" arg
                                              )
                                          )
                                      )
                                  ),
                                  "packet-log" (
                                      c(
                                          "total-memory" arg,
                                          "max-sessions" arg,
                                          "threshold-logging-interval" arg,
                                          "source-address" (
                                            ipv4addr
                                          ),
                                          "host" (
                                              c(
                                                    ipv4addr,
                                                  "port" arg
                                              )
                                          )
                                      )
                                  ),
                                  "application-identification" (
                                      c(
                                            ("disable"),
                                          "application-system-cache",
                                          "no-application-system-cache",
                                          "max-tcp-session-packet-memory" arg,
                                          "max-udp-session-packet-memory" arg,
                                          "max-sessions" arg,
                                          "max-packet-memory" arg,
                                          "max-packet-memory-ratio" arg,
                                          "max-reass-packet-memory-ratio" arg,
                                          "application-system-cache-timeout" arg
                                      )
                                  ),
                                  "flow" (
                                      c(
                                          "log-errors",
                                          "no-log-errors",
                                          "reset-on-policy",
                                          "no-reset-on-policy",
                                          "allow-icmp-without-flow",
                                          "no-allow-icmp-without-flow",
                                          "hash-table-size" arg,
                                          "reject-timeout" arg,
                                          "max-timers-poll-ticks" arg,
                                          "fifo-max-size" arg,
                                          "udp-anticipated-timeout" arg,
                                          "allow-nonsyn-connection",
                                          "drop-on-limit",
                                          "drop-on-failover",
                                          "drop-if-no-policy-loaded",
                                          "max-sessions-offset" arg,
                                          "min-objcache-limit-lt" arg,
                                          "min-objcache-limit-ut" arg,
                                          "session-steering",
                                          "idp-bypass-cpu-usg-overload",
                                          "idp-bypass-cpu-threshold" arg,
                                          "idp-bypass-cpu-tolerance" arg
                                      )
                                  ),
                                  "re-assembler" (
                                      c(
                                          "drop-on-syn-in-window",
                                          "no-drop-on-syn-in-window",
                                          "ignore-memory-overflow",
                                          "no-ignore-memory-overflow",
                                          "ignore-reassembly-memory-overflow",
                                          "no-ignore-reassembly-memory-overflow",
                                          "ignore-reassembly-overflow",
                                          "max-packet-mem" arg,
                                          "max-flow-mem" arg,
                                          "max-packet-mem-ratio" arg,
                                          "action-on-reassembly-failure" (
                                            ("ignore" | "drop" | "drop-session")
                                          ),
                                          "tcp-error-logging",
                                          "no-tcp-error-logging",
                                          "max-synacks-queued" arg,
                                          "force-tcp-window-checks",
                                          "no-force-tcp-window-checks"
                                      )
                                  ),
                                  "ips" (
                                      c(
                                          "process-override",
                                          "no-process-override",
                                          "detect-shellcode",
                                          "no-detect-shellcode",
                                          "process-ignore-s2c",
                                          "no-process-ignore-s2c",
                                          "ignore-regular-expression",
                                          "no-ignore-regular-expression",
                                          "process-port" arg,
                                          "fifo-max-size" arg,
                                          "log-supercede-min" arg,
                                          "content-decompression-max-memory-kb" arg,
                                          "content-decompression-max-ratio" arg,
                                          "session-pkt-depth" arg
                                      )
                                  ),
                                  "global" (
                                      c(
                                          "enable-packet-pool",
                                          "no-enable-packet-pool",
                                          "enable-all-qmodules",
                                          "no-enable-all-qmodules",
                                          "policy-lookup-cache",
                                          "no-policy-lookup-cache",
                                          "memory-limit-percent" arg
                                      )
                                  ),
                                  "detector" (
                                      c(
                                          "protocol-name" (
                                            proto_object
                                          )
                                      )
                                  ),
                                  "ssl-inspection" (
                                      c(
                                          "sessions" arg,
                                          "session-id-cache-timeout" arg,
                                          "maximum-cache-size" arg,
                                          "cache-prune-chunk-size" arg,
                                          "key-protection"
                                      )
                                  ),
                                  "disable-low-memory-handling",
                                  "high-availability" (
                                      c(
                                          "no-policy-cold-synchronization"
                                      )
                                  ),
                                  "security-configuration" (
                                      c(
                                          "protection-mode" (
                                            ("datacenter" | "datacenter-full" | "perimeter" | "perimeter-full")
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "macsec" (
                    security_macsec
                  )
              )
          ),
          "interfaces" (
              c(
                  "pic-set" arg (
                      c(
                          "interface" arg,
                          "fpc" arg (
                              c(
                                  "pic" arg
                              )
                          )
                      )
                  ),
                  "interface-set" ("$junos-interface-set-name" | arg | "$junos-svlan-interface-set-name" | "$junos-tagged-vlan-interface-set-name" | "$junos-phy-ifd-interface-set-name" | "$junos-pon-id-interface-set-name") (
                      c(
                          "targeted-distribution",
                          "targeted-options",
                          "interface" arg (
                              c(
                                  "unit" arg,
                                  "vlan-tags-outer" arg
                              )
                          ),
                          "pppoe-underlying-options" (
                            pppoe_underlying_options_type
                          )
                      )
                  ),
                  "traceoptions" (
                      c(
                          "no-remote-trace",
                          "file" (
                              c(
                                    arg,
                                  "size" arg,
                                  "files" arg,
                                  "world-readable",
                                  "no-world-readable",
                                  "match" (
                                    regular_expression
                                  )
                              )
                          ).as(:oneline),
                          "flag" (("all" | "kernel" | "change-events" | "kernel-detail" | "config-states" | "resource-usage" | "gres-events" | "select-events" | "bfd-events" | "lib-events" | "reserved" | "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "informational" | "debugging" | "verbose" | "japi")) (
                              c(
                                  "disable"
                              )
                          ).as(:oneline)
                      )
                  ),
                  "interface-range" arg (
                      c(
                          "member" arg,
                          "member-range" arg (
                              c(
                                  "end-range" (
                                    interface_device
                                  )
                              )
                          ).as(:oneline),
                          "description" arg,
                          "metadata" arg,
                            ("disable"),
                          "promiscuous-mode",
                          "port-mirror-instance" arg,
                          "multicast-statistics",
                          "oam-on-svlan",
                          "fabric-options" (
                              c(
                                  "member-interfaces" arg
                              )
                          ),
                          "traceoptions" (
                              c(
                                  "flag" (("ipc" | "event" | "media" | "all")).as(:oneline)
                              )
                          ),
                          "passive-monitor-mode",
                          c(
                            "keepalives" (
                              keepalives_type
                            ).as(:oneline),
                            "no-keepalives"
                          ),
                          "traps",
                          "no-traps",
                          "interface-mib",
                          "no-interface-mib",
                          "accounting-profile" arg,
                          "anchor-point" (
                              c(
                                    interface_device
                              )
                          ),
                          "bypass-queueing-chip",
                          "no-bypass-queueing-chip",
                          c(
                            "per-unit-scheduler",
                            "no-per-unit-scheduler",
                            "shared-scheduler",
                            "hierarchical-scheduler" (
                                c(
                                    "maximum-hierarchy-levels" arg,
                                    "implicit-hierarchy"
                                )
                            ).as(:oneline)
                          ),
                          "l2tp-maximum-session" arg,
                          "schedulers" arg,
                          "interface-transmit-statistics",
                          "cascade-port",
                          "dce",
                          c(
                            "vlan-tagging",
                            "stacked-vlan-tagging",
                            "flexible-vlan-tagging",
                            "vlan-vci-tagging"
                          ),
                          "native-vlan-id" arg,
                          "no-native-vlan-insert",
                          "speed" (
                            ("auto" | "auto-10m-100m" | "10m" | "100m" | "1g" | "10g" | "40g" | "oc3" | "oc12" | "oc48")
                          ),
                          "forwarding-class-accounting" (
                              c(
                                  "direction" (
                                    ("ingress" | "egress" | "both")
                                  ),
                                  "enhanced" (
                                      c(
                                          "traffic-type" (
                                            ("unicast-statistics" | "multicast-statistics")
                                          ),
                                          "family" (
                                            ("inet" | "inet6" | "both")
                                          ),
                                          "direction" (
                                            ("ingress" | "egress" | "both")
                                          ),
                                          "overhead-bytes" arg
                                      )
                                  )
                              )
                          ),
                          "auto-configure" (
                            auto_configure_vlan_type
                          ),
                          "mtu" arg,
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline),
                          "damping" (
                              c(
                                  "half-life" arg,
                                  "max-suppress" arg,
                                  "reuse" arg,
                                  "suppress" arg,
                                  "enable"
                              )
                          ),
                          "link-degrade-monitor" (
                              c(
                                  "actions" (
                                      c(
                                          c(
                                            "media-based"
                                          )
                                      )
                                  ),
                                  "recovery" (
                                      c(
                                          "timer" arg,
                                          c(
                                            "auto",
                                            "manual"
                                          )
                                      )
                                  ),
                                  "thresholds" (
                                      c(
                                          "set" arg,
                                          "clear" arg,
                                          "warning-set" arg,
                                          "warning-clear" arg,
                                          "interval" arg
                                      )
                                  )
                              )
                          ),
                          "satop-options" (
                              c(
                                  "idle-pattern" arg,
                                  "payload-size" arg,
                                  "excessive-packet-loss-rate" (
                                      c(
                                          "threshold" arg,
                                          "sample-period" arg
                                      )
                                  ),
                                  c(
                                    "jitter-buffer-packets" arg,
                                    "jitter-buffer-latency" arg,
                                    "jitter-buffer-auto-adjust"
                                  ),
                                  "bit-rate" arg
                              )
                          ),
                          "cesopsn-options" (
                              c(
                                  "idle-pattern" arg,
                                  "packetization-latency" arg,
                                  "payload-size" arg,
                                  "excessive-packet-loss-rate" (
                                      c(
                                          "threshold" arg,
                                          "sample-period" arg
                                      )
                                  ),
                                  c(
                                    "jitter-buffer-packets" arg,
                                    "jitter-buffer-latency" arg,
                                    "jitter-buffer-auto-adjust"
                                  ),
                                  "bit-rate" arg
                              )
                          ),
                          "ima-group-options" (
                              c(
                                  "frame-length" (
                                    ("32" | "64" | "128" | "256")
                                  ),
                                  "symmetry" (
                                    ("symmetrical-config-and-operation" | "symmetrical-config-asymmetrical-operation")
                                  ),
                                  "transmit-clock" (
                                    ("common" | "independent")
                                  ),
                                  "version" (
                                    ("1.0" | "1.1")
                                  ),
                                  "minimum-links" (
                                      c(
                                          c(
                                              arg
                                          )
                                      )
                                  ),
                                  "frame-synchronization" (
                                      c(
                                          "alpha" arg,
                                          "beta" arg,
                                          "gamma" arg
                                      )
                                  ),
                                  "test-procedure" (
                                      c(
                                          "period" arg,
                                          "interface" (
                                            interface_device
                                          ),
                                          "pattern" arg
                                      )
                                  ),
                                  "differential-delay" arg
                              )
                          ),
                          "ima-link-options" (
                              c(
                                  "group-id" arg
                              )
                          ),
                          "multi-chassis-protection" (
                            multi_chassis_protection_group
                          ),
                          "clocking" (
                              c(
                                  c(
                                    "internal",
                                    "external"
                                  )
                              )
                          ).as(:oneline),
                          "link-mode" (
                            ("automatic" | "half-duplex" | "full-duplex")
                          ),
                          "media-type" (
                            ("copper" | "fiber")
                          ),
                          "encapsulation" (
                            ("ethernet" | "fddi" | "token-ring" | "ppp" | "ppp-ccc" | "ppp-tcc" | "ether-vpls-ppp" | "frame-relay" | "frame-relay-ccc" | "frame-relay-tcc" | "extended-frame-relay-ccc" | "extended-frame-relay-tcc" | "flexible-frame-relay" | "frame-relay-port-ccc" | "frame-relay-ether-type" | "frame-relay-ether-type-tcc" | "extended-frame-relay-ether-type-tcc" | "cisco-hdlc" | "cisco-hdlc-ccc" | "cisco-hdlc-tcc" | "vlan-ccc" | "extended-vlan-ccc" | "ethernet-ccc" | "flexible-ethernet-services" | "smds-dxi" | "atm-pvc" | "atm-ccc-cell-relay" | "ethernet-over-atm" | "ethernet-tcc" | "extended-vlan-tcc" | "multilink-frame-relay-uni-nni" | "satop" | "cesopsn" | "ima" | "ethernet-vpls" | "ethernet-bridge" | "vlan-vpls" | "vlan-vci-ccc" | "extended-vlan-vpls" | "extended-vlan-bridge" | "multilink-ppp" | "generic-services")
                          ),
                          "esi" (
                              c(
                                    esi,
                                  c(
                                    "single-active",
                                    "all-active"
                                  ),
                                  "source-bmac" (
                                    mac_unicast
                                  )
                              )
                          ),
                          "framing" (
                              c(
                                  c(
                                    "lan-phy",
                                    "wan-phy",
                                    "sonet",
                                    "sdh"
                                  )
                              )
                          ),
                          "unidirectional",
                          "lmi" (
                              c(
                                  "n391dte" arg,
                                  "n392dce" arg,
                                  "n392dte" arg,
                                  "n393dce" arg,
                                  "n393dte" arg,
                                  "t391dte" arg,
                                  "t392dce" arg,
                                  "lmi-type" (
                                    ("ansi" | "itu" | "c-lmi")
                                  )
                              )
                          ),
                          "mlfr-uni-nni-bundle-options" (
                              c(
                                  "cisco-interoperability" (
                                      c(
                                          "send-lip-remove-link-for-link-reject"
                                      )
                                  ),
                                  "mrru" arg,
                                  "yellow-differential-delay" arg,
                                  "red-differential-delay" arg,
                                  "action-red-differential-delay" (
                                    ("remove-link" | "disable-tx")
                                  ),
                                  "fragment-threshold" arg,
                                  "drop-timeout" arg,
                                  "link-layer-overhead" (
                                    unsigned_float
                                  ),
                                  "lmi-type" (
                                    ("ansi" | "itu" | "c-lmi")
                                  ),
                                  "minimum-links" arg,
                                  "hello-timer" arg,
                                  "acknowledge-timer" arg,
                                  "acknowledge-retries" arg,
                                  "n391" arg,
                                  "n392" arg,
                                  "n393" arg,
                                  "t391" arg,
                                  "t392" arg
                              )
                          ),
                          "mac" (
                            mac_unicast
                          ),
                          "receive-bucket" (
                            dcd_rx_bucket_config
                          ),
                          "transmit-bucket" (
                            dcd_tx_bucket_config
                          ),
                          "shared-interface",
                          "sonet-options" (
                            sonet_options_type
                          ),
                          "logical-tunnel-options" (
                              c(
                                  "per-unit-mac-disable"
                              )
                          ),
                          "aggregated-sonet-options" (
                              c(
                                  "minimum-links" arg,
                                  "link-speed" (
                                    ("oc3" | "oc12" | "oc48" | "oc192" | "oc768" | "mixed")
                                  ),
                                  "minimum-bandwidth" arg
                              )
                          ),
                          "atm-options" (
                              c(
                                  "pic-type" (
                                    ("atm-ce" | "atm2" | "atm1")
                                  ),
                                  "cell-bundle-size" arg,
                                  "cell-bundle-timeout" arg,
                                  "plp-to-clp",
                                  "use-null-cw",
                                  "promiscuous-mode" (
                                      c(
                                          "vpi" arg.as(:oneline)
                                      )
                                  ),
                                  "vpi" arg (
                                      c(
                                          "maximum-vcs" arg,
                                          "shaping" (
                                            dcd_shaping_config
                                          ),
                                          "oam-period" (
                                              c(
                                                  c(
                                                      arg,
                                                    "disable".as(:oneline)
                                                  )
                                              )
                                          ).as(:oneline),
                                          "oam-liveness" (
                                              c(
                                                  "up-count" arg,
                                                  "down-count" arg
                                              )
                                          )
                                      )
                                  ),
                                  "ilmi",
                                  "linear-red-profiles" arg (
                                      c(
                                          "queue-depth" arg,
                                          "high-plp-threshold" arg,
                                          "low-plp-threshold" arg,
                                          "high-plp-max-threshold" arg,
                                          "low-plp-max-threshold" arg
                                      )
                                  ).as(:oneline),
                                  "scheduler-maps" arg (
                                      c(
                                          "vc-cos-mode" (
                                            ("strict" | "alternate")
                                          ),
                                          "forwarding-class" arg (
                                              c(
                                                  "priority" (
                                                    ("low" | "high")
                                                  ),
                                                  "transmit-weight" (
                                                      c(
                                                          c(
                                                            "percent" arg,
                                                            "cells" arg
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  c(
                                                    "epd-threshold" (
                                                      epd_threshold_config
                                                    ).as(:oneline),
                                                    "linear-red-profile" arg
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "mpls" (
                                    mpls_ifd_options
                                  ),
                                  "payload-scrambler",
                                  "no-payload-scrambler"
                              )
                          ),
                          "multiservice-options" (
                              c(
                                  "syslog",
                                  "no-syslog",
                                  "core-dump",
                                  "no-core-dump",
                                  "dump-on-flow-control",
                                  "no-dump-on-flow-control",
                                  "reset-on-flow-control",
                                  "no-reset-on-flow-control",
                                  "flow-control-options" (
                                      c(
                                          "dump-on-flow-control",
                                          "reset-on-flow-control",
                                          "down-on-flow-control"
                                      )
                                  )
                              )
                          ),
                          "ggsn-options" (
                              c(
                                  "syslog",
                                  "no-syslog",
                                  "core-dump",
                                  "no-core-dump"
                              )
                          ),
                          "ppp-options" (
                            ppp_options_type
                          ),
                          "redundancy-options" (
                              c(
                                  "primary" (
                                    interface_device
                                  ),
                                  "secondary" (
                                    interface_device
                                  ),
                                  "redundancy-peer" (
                                      c(
                                          "ipaddress" (
                                            ipv4addr
                                          )
                                      )
                                  ),
                                  "redundancy-local" (
                                      c(
                                          "data-address" (
                                            ipv4addr
                                          )
                                      )
                                  ),
                                  "routing-instance" arg,
                                  "replication-threshold" arg,
                                  "replication-options" (
                                      c(
                                          "mtu" arg
                                      )
                                  ),
                                  "replicate-services" (
                                      c(
                                          "pgcp"
                                      )
                                  )
                              )
                          ),
                          "load-balancing-options" (
                              c(
                                  "member-interface" arg,
                                  "member-failure-options" (
                                      c(
                                          c(
                                            "redistribute-all-traffic" (
                                                c(
                                                    "enable-rejoin"
                                                )
                                            ),
                                            "drop-member-traffic" (
                                                c(
                                                    "rejoin-timeout" arg,
                                                    "enable-rejoin"
                                                )
                                            )
                                          )
                                      )
                                  ),
                                  "high-availability-options" (
                                      c(
                                          c(
                                            "many-to-one" (
                                                c(
                                                    "preferred-backup" (
                                                      interface_device
                                                    )
                                                )
                                            ),
                                            "one-to-one" (
                                                c(
                                                    "preferred-backup" (
                                                      interface_device
                                                    )
                                                )
                                            )
                                          )
                                      )
                                  )
                              )
                          ),
                          "aggregated-inline-services-options" (
                              c(
                                  "primary-interface" (
                                    interface_device
                                  ),
                                  "secondary-interface" (
                                    interface_device
                                  )
                              )
                          ),
                          "anchoring-options" (
                              c(
                                  "apfe-group-set" arg,
                                  "primary-list" arg,
                                  "secondary" (
                                      c(
                                          arg
                                      )
                                  ),
                                  c(
                                    "warm-standby"
                                  )
                              )
                          ),
                          "lsq-failure-options" (
                              c(
                                  "trigger-link-failure" arg,
                                  "no-termination-request",
                                  "no-no-termination-request"
                              )
                          ),
                          "redundancy-group" (
                              c(
                                  "member-interface" arg (
                                      c(
                                          c(
                                            "active",
                                            "backup"
                                          )
                                      )
                                  ),
                                  "maximum-links" arg
                              )
                          ),
                          "services-options" (
                              c(
                                  "syslog" (
                                    service_set_syslog_object
                                  ),
                                  "jflow-log" (
                                      c(
                                          "message-rate-limit" arg
                                      )
                                  ),
                                  "open-timeout" arg,
                                  "close-timeout" arg,
                                  "inactivity-timeout" arg,
                                  "inactivity-tcp-timeout" arg,
                                  "inactivity-asymm-tcp-timeout" arg,
                                  "inactivity-non-tcp-timeout" arg,
                                  "session-timeout" arg,
                                  "disable-global-timeout-override",
                                  "tcp-tickles" arg,
                                  "trio-flow-offload" (
                                      c(
                                          "minimum-bytes" arg
                                      )
                                  ),
                                  "fragment-limit" arg,
                                  "reassembly-timeout" arg,
                                  "cgn-pic",
                                  "pba-interim-logging-interval" arg,
                                  "session-limit" (
                                      c(
                                          "maximum" arg,
                                          "rate" arg,
                                          "cpu-load-threshold" arg
                                      )
                                  ),
                                  "ignore-errors" (
                                      c(
                                          "tcp",
                                          "alg"
                                      )
                                  ).as(:oneline),
                                  "capture" (
                                      c(
                                          "capture-size" arg,
                                          "pkt-size" arg,
                                          "logs-per-packet" arg,
                                          "max-log-line-size" arg,
                                          "filter" (
                                              c(
                                                  "source-ip" (
                                                      c(
                                                            ipaddr,
                                                          "wildcard" (
                                                            ipaddr
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "dest-ip" (
                                                      c(
                                                            ipaddr,
                                                          "wildcard" (
                                                            ipaddr
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "sw-sip" (
                                                      c(
                                                            ipv6addr,
                                                          "wildcard" (
                                                            ipv6addr
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "sw-dip" (
                                                      c(
                                                            ipaddr,
                                                          "wildcard" (
                                                            ipaddr
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "sport-range" (
                                                      c(
                                                          "low" arg,
                                                          "high" arg
                                                      )
                                                  ).as(:oneline),
                                                  "dport-range" (
                                                      c(
                                                          "low" arg,
                                                          "high" arg
                                                      )
                                                  ).as(:oneline),
                                                  "proto" (
                                                    ("icmp" | "tcp" | "udp")
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "t3-options" (
                              c(
                                  "loopback" (
                                    ("local" | "remote" | "payload")
                                  ),
                                  "long-buildout",
                                  "no-long-buildout",
                                  "loop-timing",
                                  "no-loop-timing",
                                  "unframed",
                                  "no-unframed",
                                  "compatibility-mode" (
                                      c(
                                          c(
                                            "larscom" (
                                                c(
                                                    "subrate" arg
                                                )
                                            ).as(:oneline),
                                            "verilink" (
                                                c(
                                                    "subrate" arg
                                                )
                                            ).as(:oneline),
                                            "adtran" (
                                                c(
                                                    "subrate" arg
                                                )
                                            ).as(:oneline),
                                            "kentrox" (
                                                c(
                                                    "subrate" arg
                                                )
                                            ).as(:oneline),
                                            "digital-link" (
                                                c(
                                                    "subrate" (
                                                      ("301Kb" | "601Kb" | "902Kb" | "1.2Mb" | "1.5Mb" | "1.8Mb" | "2.1Mb" | "2.4Mb" | "2.7Mb" | "3.0Mb" | "3.3Mb" | "3.6Mb" | "3.9Mb" | "4.2Mb" | "4.5Mb" | "4.8Mb" | "5.1Mb" | "5.4Mb" | "5.7Mb" | "6.0Mb" | "6.3Mb" | "6.6Mb" | "6.9Mb" | "7.2Mb" | "7.5Mb" | "7.8Mb" | "8.1Mb" | "8.4Mb" | "8.7Mb" | "9.0Mb" | "9.3Mb" | "9.6Mb" | "9.9Mb" | "10.2Mb" | "10.5Mb" | "10.8Mb" | "11.1Mb" | "11.4Mb" | "11.7Mb" | "12.0Mb" | "12.3Mb" | "12.6Mb" | "12.9Mb" | "13.2Mb" | "13.5Mb" | "13.8Mb" | "14.1Mb" | "14.4Mb" | "14.7Mb" | "15.0Mb" | "15.3Mb" | "15.6Mb" | "15.9Mb" | "16.2Mb" | "16.5Mb" | "16.8Mb" | "17.1Mb" | "17.4Mb" | "17.7Mb" | "18.0Mb" | "18.3Mb" | "18.6Mb" | "18.9Mb" | "19.2Mb" | "19.5Mb" | "19.8Mb" | "20.1Mb" | "20.5Mb" | "20.8Mb" | "21.1Mb" | "21.4Mb" | "21.7Mb" | "22.0Mb" | "22.3Mb" | "22.6Mb" | "22.9Mb" | "23.2Mb" | "23.5Mb" | "23.8Mb" | "24.1Mb" | "24.4Mb" | "24.7Mb" | "25.0Mb" | "25.3Mb" | "25.6Mb" | "25.9Mb" | "26.2Mb" | "26.5Mb" | "26.8Mb" | "27.1Mb" | "27.4Mb" | "27.7Mb" | "28.0Mb" | "28.3Mb" | "28.6Mb" | "28.9Mb" | "29.2Mb" | "29.5Mb" | "29.8Mb" | "30.1Mb" | "30.4Mb" | "30.7Mb" | "31.0Mb" | "31.3Mb" | "31.6Mb" | "31.9Mb" | "32.2Mb" | "32.5Mb" | "32.8Mb" | "33.1Mb" | "33.4Mb" | "33.7Mb" | "34.0Mb" | "34.3Mb" | "34.6Mb" | "34.9Mb" | "35.2Mb" | "35.5Mb" | "35.8Mb" | "36.1Mb" | "36.4Mb" | "36.7Mb" | "37.0Mb" | "37.3Mb" | "37.6Mb" | "37.9Mb" | "38.2Mb" | "38.5Mb" | "38.8Mb" | "39.1Mb" | "39.4Mb" | "39.7Mb" | "40.0Mb" | "40.3Mb" | "40.6Mb" | "40.9Mb" | "41.2Mb" | "41.5Mb" | "41.8Mb" | "42.1Mb" | "42.4Mb" | "42.7Mb" | "43.0Mb" | "43.3Mb" | "43.6Mb" | "43.9Mb" | "44.2Mb")
                                                    )
                                                )
                                            ).as(:oneline)
                                          )
                                      )
                                  ).as(:oneline),
                                  "payload-scrambler",
                                  "no-payload-scrambler",
                                  "cbit-parity",
                                  "no-cbit-parity",
                                  "fcs" (
                                    ("32" | "16")
                                  ),
                                  "idle-cycle-flag" (
                                    ("flags" | "ones")
                                  ),
                                  "start-end-flag" (
                                    ("shared" | "filler")
                                  ),
                                  "feac-loop-respond",
                                  "no-feac-loop-respond",
                                  "bert-algorithm" (
                                    ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                  ),
                                  "bert-error-rate" arg,
                                  "bert-period" arg,
                                  "buildout" arg,
                                  "atm-encapsulation" (
                                    ("plcp" | "direct")
                                  )
                              )
                          ),
                          "e3-options" (
                              c(
                                  "loopback" (
                                    ("local" | "remote")
                                  ),
                                  "unframed",
                                  "no-unframed",
                                  "compatibility-mode" (
                                      c(
                                          c(
                                            "larscom",
                                            "digital-link" (
                                                c(
                                                    "subrate" (
                                                      ("358Kb" | "716Kb" | "1.1Mb" | "1.4Mb" | "1.8Mb" | "2.1Mb" | "2.5Mb" | "2.9Mb" | "3.2Mb" | "3.6Mb" | "3.9Mb" | "4.3Mb" | "4.7Mb" | "5.0Mb" | "5.4Mb" | "5.7Mb" | "6.1Mb" | "6.4Mb" | "6.8Mb" | "7.2Mb" | "7.5Mb" | "7.9Mb" | "8.2Mb" | "8.6Mb" | "9.0Mb" | "9.3Mb" | "9.7Mb" | "10.0Mb" | "10.4Mb" | "10.7Mb" | "11.1Mb" | "11.5Mb" | "11.8Mb" | "12.2Mb" | "12.5Mb" | "12.9Mb" | "13.2Mb" | "13.6Mb" | "14.0Mb" | "14.3Mb" | "14.7Mb" | "15.0Mb" | "15.4Mb" | "15.8Mb" | "16.1Mb" | "16.5Mb" | "16.8Mb" | "17.2Mb" | "17.5Mb" | "17.9Mb" | "18.3Mb" | "18.6Mb" | "19.0Mb" | "19.3Mb" | "19.7Mb" | "20.0Mb" | "20.4Mb" | "20.8Mb" | "21.1Mb" | "21.5Mb" | "21.8Mb" | "22.2Mb" | "22.6Mb" | "22.9Mb" | "23.3Mb" | "23.6Mb" | "24.0Mb" | "24.3Mb" | "24.7Mb" | "25.1Mb" | "25.4Mb" | "25.8Mb" | "26.1Mb" | "26.5Mb" | "26.9Mb" | "27.2Mb" | "27.6Mb" | "27.9Mb" | "28.3Mb" | "28.6Mb" | "29.0Mb" | "29.4Mb" | "29.7Mb" | "30.1Mb" | "30.4Mb" | "30.8Mb" | "31.1Mb" | "31.5Mb" | "31.9Mb" | "32.2Mb" | "32.6Mb" | "32.9Mb" | "33.3Mb" | "33.7Mb" | "34.0Mb")
                                                    )
                                                )
                                            ).as(:oneline),
                                            "kentrox" (
                                                c(
                                                    "subrate" arg
                                                )
                                            ).as(:oneline)
                                          )
                                      )
                                  ).as(:oneline),
                                  "payload-scrambler",
                                  "no-payload-scrambler",
                                  "fcs" (
                                    ("32" | "16")
                                  ),
                                  "idle-cycle-flag" (
                                    ("flags" | "ones")
                                  ),
                                  "invert-data",
                                  "start-end-flag" (
                                    ("shared" | "filler")
                                  ),
                                  "bert-algorithm" (
                                    ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                  ),
                                  "bert-error-rate" arg,
                                  "bert-period" arg,
                                  "buildout" arg,
                                  "atm-encapsulation" (
                                    ("plcp" | "direct")
                                  ),
                                  "framing" (
                                    ("g.751" | "g.832")
                                  )
                              )
                          ),
                          "e1-options" (
                              c(
                                  "timeslots" arg,
                                  "loopback" (
                                    ("local" | "remote")
                                  ),
                                  "framing" (
                                    ("g704" | "unframed" | "g704-no-crc4")
                                  ),
                                  "fcs" (
                                    ("32" | "16")
                                  ),
                                  "invert-data",
                                  "idle-cycle-flag" (
                                    ("flags" | "ones")
                                  ),
                                  "start-end-flag" (
                                    ("shared" | "filler")
                                  ),
                                  "bert-algorithm" (
                                    ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                  ),
                                  "bert-error-rate" arg,
                                  "bert-period" arg
                              )
                          ),
                          "t1-options" (
                              c(
                                  "timeslots" arg,
                                  "voice-timeslots" arg,
                                  "disable-remote-alarm-detection" (
                                    ("yellow")
                                  ),
                                  "loopback" (
                                    ("local" | "remote" | "payload")
                                  ),
                                  "buildout" (
                                    ("0-132" | "133-265" | "266-398" | "399-531" | "532-655" | "long-0db" | "long-7.5db" | "long-15db" | "long-22.5db")
                                  ),
                                  "byte-encoding" (
                                    ("nx64" | "nx56")
                                  ),
                                  "line-encoding" (
                                    ("ami" | "b8zs")
                                  ),
                                  "invert-data",
                                  "framing" (
                                    ("sf" | "esf")
                                  ),
                                  "fcs" (
                                    ("32" | "16")
                                  ),
                                  "idle-cycle-flag" (
                                    ("flags" | "ones")
                                  ),
                                  "start-end-flag" (
                                    ("shared" | "filler")
                                  ),
                                  "bert-algorithm" (
                                    ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                  ),
                                  "bert-error-rate" arg,
                                  "bert-period" arg,
                                  "remote-loopback-respond",
                                  "crc-major-alarm-threshold" (
                                    ("1e-3" | "5e-4" | "1e-4" | "5e-5" | "1e-5")
                                  ),
                                  "crc-minor-alarm-threshold" (
                                    ("1e-3" | "5e-4" | "1e-4" | "5e-5" | "1e-5" | "5e-6" | "1e-6")
                                  ),
                                  "alarm-compliance" (
                                    ("accunet-t1-5-service")
                                  )
                              )
                          ),
                          "ds0-options" (
                              c(
                                  "loopback" (
                                    ("payload")
                                  ),
                                  "byte-encoding" (
                                    ("nx64" | "nx56")
                                  ),
                                  "invert-data",
                                  "fcs" (
                                    ("32" | "16")
                                  ),
                                  "idle-cycle-flag" (
                                    ("flags" | "ones")
                                  ),
                                  "start-end-flag" (
                                    ("shared" | "filler")
                                  ),
                                  "bert-algorithm" (
                                    ("pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4" | "repeating-1-in-16")
                                  ),
                                  "bert-error-rate" arg,
                                  "bert-period" arg
                              )
                          ),
                          "serial-options" (
                              c(
                                  "line-protocol" (
                                    ("eia530" | "v.35" | "x.21")
                                  ),
                                  c(
                                    "dte-options" (
                                        c(
                                            "ignore-all",
                                            "dtr" (
                                                c(
                                                    c(
                                                      "assert",
                                                      "de-assert",
                                                      "normal",
                                                      "auto-synchronize" (
                                                          c(
                                                              "duration" arg,
                                                              "interval" arg
                                                          )
                                                      )
                                                    )
                                                )
                                            ).as(:oneline),
                                            "control-signal" (
                                              ("assert" | "de-assert" | "normal")
                                            ),
                                            "rts" (
                                              ("assert" | "de-assert" | "normal")
                                            ),
                                            "dcd" (
                                              ("require" | "ignore" | "normal")
                                            ),
                                            "dsr" (
                                              ("require" | "ignore" | "normal")
                                            ),
                                            "cts" (
                                              ("require" | "ignore" | "normal")
                                            ),
                                            "indication" (
                                              ("require" | "ignore" | "normal")
                                            ),
                                            "tm" (
                                              ("require" | "ignore" | "normal")
                                            )
                                        )
                                    ),
                                    "dce-options" (
                                        c(
                                            "ignore-all",
                                            "dtr" (
                                              ("require" | "ignore" | "normal")
                                            ),
                                            "rts" (
                                              ("require" | "ignore" | "normal")
                                            ),
                                            "dcd" (
                                              ("assert" | "de-assert" | "normal")
                                            ),
                                            "dsr" (
                                              ("assert" | "de-assert" | "normal")
                                            ),
                                            "cts" (
                                              ("assert" | "de-assert" | "normal")
                                            ),
                                            "tm" (
                                              ("require" | "ignore" | "normal")
                                            ),
                                            "dce-loopback-override"
                                        )
                                    )
                                  ),
                                  "dtr-circuit" (
                                    ("balanced" | "unbalanced")
                                  ),
                                  "dtr-polarity" (
                                    ("positive" | "negative")
                                  ),
                                  "rts-polarity" (
                                    ("positive" | "negative")
                                  ),
                                  "control-polarity" (
                                    ("positive" | "negative")
                                  ),
                                  "dcd-polarity" (
                                    ("positive" | "negative")
                                  ),
                                  "dsr-polarity" (
                                    ("positive" | "negative")
                                  ),
                                  "cts-polarity" (
                                    ("positive" | "negative")
                                  ),
                                  "indication-polarity" (
                                    ("positive" | "negative")
                                  ),
                                  "tm-polarity" (
                                    ("positive" | "negative")
                                  ),
                                  "clocking-mode" (
                                    ("dce" | "internal" | "loop")
                                  ),
                                  "transmit-clock" (
                                    ("invert")
                                  ),
                                  "clock-rate" (
                                    ("2.048mhz" | "2.341mhz" | "2.731mhz" | "3.277mhz" | "4.096mhz" | "5.461mhz" | "8.192mhz" | "16.384mhz" | "1.2khz" | "2.4khz" | "9.6khz" | "19.2khz" | "38.4khz" | "56.0khz" | "64.0khz" | "72.0khz" | "125.0khz" | "148.0khz" | "250.0khz" | "500.0khz" | "800.0khz" | "1.0mhz" | "1.3mhz" | "2.0mhz" | "4.0mhz" | "8.0mhz")
                                  ),
                                  "loopback" (
                                    ("local" | "remote" | "dce-local" | "dce-remote")
                                  ),
                                  "encoding" (
                                    ("nrz" | "nrzi")
                                  ),
                                  "idle-cycle-flag" (
                                    ("flags" | "ones")
                                  )
                              )
                          ),
                          "gratuitous-arp-reply",
                          "no-gratuitous-arp-reply",
                          "no-gratuitous-arp-request",
                          "no-no-gratuitous-arp-request",
                          "arp-l2-validate",
                          "ether-options" (
                              c(
                                  "loopback",
                                  "no-loopback",
                                  "source-filtering",
                                  "no-source-filtering",
                                  "ethernet-switch-profile" (
                                      c(
                                          "tag-protocol-id" arg,
                                          "ethernet-policer-profile" (
                                              c(
                                                  "input-priority-map" (
                                                    cos_policer_input_priority_map
                                                  ),
                                                  "output-priority-map" (
                                                    cos_policer_output_priority_map
                                                  ),
                                                  "policer" (
                                                    cos_policer
                                                  )
                                              )
                                          ),
                                          "storm-control" (
                                              c(
                                                  arg
                                              )
                                          ),
                                          "recovery-timeout" (
                                              c(
                                                    arg
                                              )
                                          ).as(:oneline),
                                          "mac-learn-enable",
                                          "no-mac-learn-enable"
                                      )
                                  ),
                                  "asynchronous-notification",
                                  "source-address-filter" arg.as(:oneline),
                                  "auto-negotiation",
                                  "no-auto-negotiation",
                                  "flow-control",
                                  "no-flow-control",
                                  "configured-flow-control" (
                                      c(
                                          "rx-buffers" (
                                            ("on" | "off")
                                          ),
                                          "tx-buffers" (
                                            ("on" | "off")
                                          )
                                      )
                                  ),
                                  "link-mode" (
                                    ("automatic" | "half-duplex" | "full-duplex")
                                  ),
                                  "mpls" (
                                    mpls_ifd_options
                                  ),
                                  "ignore-l3-incompletes",
                                  "no-auto-mdix",
                                  "speed" (
                                      c(
                                          c(
                                            "auto-negotiation" (
                                                c(
                                                    "auto-negotiate-10-100"
                                                )
                                            ).as(:oneline),
                                            "ethernet-10m",
                                            "ethernet-100m",
                                            "ethernet-1g",
                                            "ethernet-10g"
                                          )
                                      )
                                  ),
                                  "ieee-802.3ad" (
                                      c(
                                          "lacp" (
                                              c(
                                                  "force-up",
                                                  "port-priority" arg
                                              )
                                          ),
                                            interface_device,
                                          c(
                                            "primary",
                                            "backup"
                                          ),
                                          "link-protection-sub-group" (
                                              c(
                                                    arg
                                              )
                                          ),
                                          "port-priority" arg
                                      )
                                  ),
                                  "ieee-802-3az-eee",
                                  "mdi-mode" (
                                    ("auto" | "force" | "mdi" | "mdix")
                                  ),
                                  "redundant-parent" (
                                      c(
                                            interface_device
                                      )
                                  ),
                                  "autostate-exclude"
                              )
                          ),
                          "fibrechannel-options" (
                              c(
                                  "loopback",
                                  "no-loopback",
                                  "bb-sc-n" arg,
                                  "speed" (
                                    ("auto-negotiation" | "1g" | "2g" | "4g" | "8g")
                                  )
                              )
                          ),
                          "gigether-options" (
                              c(
                                  "loopback",
                                  "no-loopback",
                                  "loopback-remote",
                                  "flow-control",
                                  "no-flow-control",
                                  "source-filtering",
                                  "no-source-filtering",
                                  c(
                                    "no-auto-negotiation",
                                    "auto-negotiation" (
                                        c(
                                            "remote-fault" (
                                              ("local-interface-offline" | "local-interface-online")
                                            )
                                        )
                                    ).as(:oneline)
                                  ),
                                  "mac-mode" (
                                    ("sgmii" | "mac-mode-1000base-x")
                                  ),
                                  "asynchronous-notification",
                                  "source-address-filter" arg.as(:oneline),
                                  "pad-to-minimum-frame-size",
                                  "redundant-parent" (
                                      c(
                                            interface_device
                                      )
                                  ),
                                  "ieee-802.3ad" (
                                      c(
                                          "lacp" (
                                              c(
                                                  "port-priority" arg
                                              )
                                          ),
                                            interface_device,
                                          "link-index" arg,
                                          c(
                                            "primary",
                                            "backup"
                                          ),
                                          "distribution-list" arg
                                      )
                                  ),
                                  "ethernet-switch-profile" (
                                      c(
                                          "tag-protocol-id" arg,
                                          "ethernet-policer-profile" (
                                              c(
                                                  "ieee802.1-priority-map" (
                                                      c(
                                                          "premium" arg
                                                      )
                                                  ),
                                                  "input-priority-map" (
                                                    cos_policer_input_priority_map
                                                  ),
                                                  "output-priority-map" (
                                                    cos_policer_output_priority_map
                                                  ),
                                                  "policer" (
                                                    cos_policer
                                                  )
                                              )
                                          ),
                                          "accept-from" (
                                              c(
                                                  "mac-address" (
                                                    mac_list
                                                  )
                                              )
                                          ),
                                          "reject-the-rest",
                                          "no-reject-the-rest",
                                          "mac-learn-enable"
                                      )
                                  ),
                                  "mpls" (
                                    mpls_ifd_options
                                  ),
                                  "ignore-l3-incompletes",
                                  "no-auto-mdix",
                                  "ieee-802-3az-eee",
                                  "mru" arg,
                                  "fec" (
                                    ("none" | "fec91" | "fec74")
                                  )
                              )
                          ),
                          "optics-options" (
                              c(
                                  "wavelength" (
                                    ("1568.77" | "1568.36" | "1568.26" | "1568.16" | "1568.05" | "1567.95" | "1567.85" | "1567.75" | "1567.64" | "1567.54" | "1567.44" | "1567.34" | "1567.23" | "1567.13" | "1567.03" | "1566.93" | "1566.83" | "1566.72" | "1566.62" | "1566.52" | "1566.42" | "1566.31" | "1566.21" | "1566.11" | "1566.01" | "1565.90" | "1565.80" | "1565.70" | "1565.60" | "1565.50" | "1565.39" | "1565.29" | "1565.19" | "1565.09" | "1564.99" | "1564.88" | "1564.78" | "1564.68" | "1564.58" | "1564.47" | "1564.37" | "1564.27" | "1564.17" | "1564.07" | "1563.96" | "1563.86" | "1563.76" | "1563.66" | "1563.56" | "1563.45" | "1563.35" | "1563.25" | "1563.15" | "1563.05" | "1562.95" | "1562.84" | "1562.74" | "1562.64" | "1562.54" | "1562.44" | "1562.33" | "1562.23" | "1562.13" | "1562.03" | "1561.93" | "1561.83" | "1561.72" | "1561.62" | "1561.52" | "1561.42" | "1561.32" | "1561.22" | "1561.11" | "1561.01" | "1560.91" | "1560.81" | "1560.71" | "1560.61" | "1560.50" | "1560.40" | "1560.30" | "1560.20" | "1560.10" | "1560.00" | "1559.90" | "1559.79" | "1559.69" | "1559.59" | "1559.49" | "1559.39" | "1559.29" | "1559.19" | "1559.08" | "1558.98" | "1558.88" | "1558.78" | "1558.68" | "1558.58" | "1558.48" | "1558.38" | "1558.27" | "1558.17" | "1558.07" | "1557.97" | "1557.87" | "1557.77" | "1557.67" | "1557.57" | "1557.46" | "1557.36" | "1557.26" | "1557.16" | "1557.06" | "1556.96" | "1556.86" | "1556.76" | "1556.66" | "1556.55" | "1556.45" | "1556.35" | "1556.25" | "1556.15" | "1556.05" | "1555.95" | "1555.85" | "1555.75" | "1555.65" | "1555.55" | "1555.44" | "1555.34" | "1555.24" | "1555.14" | "1555.04" | "1554.94" | "1554.84" | "1554.74" | "1554.64" | "1554.54" | "1554.44" | "1554.34" | "1554.23" | "1554.13" | "1554.03" | "1553.93" | "1553.83" | "1553.73" | "1553.63" | "1553.53" | "1553.43" | "1553.33" | "1553.23" | "1553.13" | "1553.03" | "1552.93" | "1552.83" | "1552.73" | "1552.62" | "1552.52" | "1552.42" | "1552.32" | "1552.22" | "1552.12" | "1552.02" | "1551.92" | "1551.82" | "1551.72" | "1551.62" | "1551.52" | "1551.42" | "1551.32" | "1551.22" | "1551.12" | "1551.02" | "1550.92" | "1550.82" | "1550.72" | "1550.62" | "1550.52" | "1550.42" | "1550.32" | "1550.22" | "1550.12" | "1550.02" | "1549.92" | "1549.82" | "1549.72" | "1549.62" | "1549.52" | "1549.42" | "1549.32" | "1549.21" | "1549.11" | "1549.01" | "1548.91" | "1548.81" | "1548.71" | "1548.61" | "1548.51" | "1548.41" | "1548.31" | "1548.21" | "1548.11" | "1548.02" | "1547.92" | "1547.82" | "1547.72" | "1547.62" | "1547.52" | "1547.42" | "1547.32" | "1547.22" | "1547.12" | "1547.02" | "1546.92" | "1546.82" | "1546.72" | "1546.62" | "1546.52" | "1546.42" | "1546.32" | "1546.22" | "1546.12" | "1546.02" | "1545.92" | "1545.82" | "1545.72" | "1545.62" | "1545.52" | "1545.42" | "1545.32" | "1545.22" | "1545.12" | "1545.02" | "1544.92" | "1544.82" | "1544.72" | "1544.63" | "1544.53" | "1544.43" | "1544.33" | "1544.23" | "1544.13" | "1544.03" | "1543.93" | "1543.83" | "1543.73" | "1543.63" | "1543.53" | "1543.43" | "1543.33" | "1543.23" | "1543.13" | "1543.04" | "1542.94" | "1542.84" | "1542.74" | "1542.64" | "1542.54" | "1542.44" | "1542.34" | "1542.24" | "1542.14" | "1542.04" | "1541.94" | "1541.84" | "1541.75" | "1541.65" | "1541.55" | "1541.45" | "1541.35" | "1541.25" | "1541.15" | "1541.05" | "1540.95" | "1540.85" | "1540.76" | "1540.66" | "1540.56" | "1540.46" | "1540.36" | "1540.26" | "1540.16" | "1540.06" | "1539.96" | "1539.86" | "1539.77" | "1539.67" | "1539.57" | "1539.47" | "1539.37" | "1539.27" | "1539.17" | "1539.07" | "1538.98" | "1538.88" | "1538.78" | "1538.68" | "1538.58" | "1538.48" | "1538.38" | "1538.28" | "1538.19" | "1538.09" | "1537.99" | "1537.89" | "1537.79" | "1537.69" | "1537.59" | "1537.50" | "1537.40" | "1537.30" | "1537.20" | "1537.10" | "1537.00" | "1536.90" | "1536.81" | "1536.71" | "1536.61" | "1536.51" | "1536.41" | "1536.31" | "1536.22" | "1536.12" | "1536.02" | "1535.92" | "1535.82" | "1535.72" | "1535.63" | "1535.53" | "1535.43" | "1535.33" | "1535.23" | "1535.13" | "1535.04" | "1534.94" | "1534.84" | "1534.74" | "1534.64" | "1534.54" | "1534.45" | "1534.35" | "1534.25" | "1534.15" | "1534.05" | "1533.96" | "1533.86" | "1533.76" | "1533.66" | "1533.56" | "1533.47" | "1533.37" | "1533.27" | "1533.17" | "1533.07" | "1532.98" | "1532.88" | "1532.78" | "1532.68" | "1532.58" | "1532.49" | "1532.39" | "1532.29" | "1532.19" | "1532.09" | "1532.00" | "1531.90" | "1531.80" | "1531.70" | "1531.60" | "1531.51" | "1531.41" | "1531.31" | "1531.21" | "1531.12" | "1531.02" | "1530.92" | "1530.82" | "1530.72" | "1530.63" | "1530.53" | "1530.43" | "1530.33" | "1530.24" | "1530.14" | "1530.04" | "1529.94" | "1529.85" | "1529.75" | "1529.65" | "1529.55" | "1529.46" | "1529.36" | "1529.26" | "1529.16" | "1529.07" | "1528.97" | "1528.87" | "1528.77" | "1528.38")
                                  ),
                                  "tx-power" arg,
                                  "loopback",
                                  "los-warning-threshold" arg,
                                  "los-alarm-threshold" arg,
                                  "modulation-format" (
                                    ("16qam" | "8qam" | "qpsk")
                                  ),
                                  "laser-enable",
                                  "no-laser-enable",
                                  "is-ma",
                                  "no-is-ma",
                                  "encoding" (
                                    ("differential" | "non-differential")
                                  ),
                                  "fec" (
                                    ("sdfec" | "sdfec25")
                                  ),
                                  "alarm" (("low-light-alarm")) (
                                      c(
                                          c(
                                            "syslog",
                                            "link-down"
                                          )
                                      )
                                  ),
                                  "tca" (
                                      c(
                                          "tx-power-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "tx-power-low-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "rx-power-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "rx-power-low-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "temperature-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "temperature-low-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "carrier-frequency-offset-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "carrier-frequency-offset-low-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "fec-ber" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ).as(:oneline),
                                          "tec-current-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "tec-current-low-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "residual-isi-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "residual-isi-low-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "pam-histogram-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "snr-low-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "fec-corrected-errors-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "fec-ucorrected-words-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "laser-frequency-error-high-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          ),
                                          "laser-frequency-error-low-tca" (
                                              c(
                                                  "enable-tca",
                                                  "no-enable-tca",
                                                  "threshold" arg,
                                                  "threshold-24hrs" arg
                                              )
                                          )
                                      )
                                  ),
                                  "warning" (("low-light-warning")) (
                                      c(
                                          c(
                                            "syslog",
                                            "link-down"
                                          )
                                      )
                                  )
                              )
                          ),
                          "otn-options" (
                            otn_options_type
                          ),
                          "fastether-options" (
                              c(
                                  "loopback",
                                  "no-loopback",
                                  "flow-control",
                                  "no-flow-control",
                                  "source-filtering",
                                  "no-source-filtering",
                                  "auto-negotiation",
                                  "no-auto-negotiation",
                                  "ingress-rate-limit" arg,
                                  "source-address-filter" arg.as(:oneline),
                                  "redundant-parent" (
                                      c(
                                            interface_device
                                      )
                                  ),
                                  "ieee-802.3ad" (
                                      c(
                                          "lacp" (
                                              c(
                                                  "port-priority" arg
                                              )
                                          ),
                                            interface_device,
                                          c(
                                            "primary",
                                            "backup"
                                          )
                                      )
                                  ),
                                  "mpls" (
                                    mpls_ifd_options
                                  ),
                                  "ignore-l3-incompletes"
                              )
                          ),
                          "redundant-ether-options" (
                              c(
                                  "redundancy-group" arg,
                                  "loopback",
                                  "no-loopback",
                                  "flow-control",
                                  "no-flow-control",
                                  "source-filtering",
                                  "no-source-filtering",
                                  "source-address-filter" arg.as(:oneline),
                                  "link-speed" (
                                    ("10m" | "100m" | "1g" | "10g")
                                  ),
                                  "minimum-links" arg,
                                  "lacp" (
                                      c(
                                          c(
                                            "active",
                                            "passive"
                                          ),
                                          "periodic" (
                                            ("fast" | "slow")
                                          )
                                      )
                                  )
                              )
                          ),
                          "aggregated-ether-options" (
                              c(
                                  "loopback",
                                  "no-loopback",
                                  "flow-control",
                                  "no-flow-control",
                                  "source-filtering",
                                  "no-source-filtering",
                                  "autostate-exclude",
                                  "link-protection" (
                                      c(
                                          "revertive",
                                          "backup-state" (
                                            ("accept-data" | "discard-data" | "down")
                                          )
                                      )
                                  ),
                                  "fcoe-lag",
                                  "no-fcoe-lag",
                                  "source-address-filter" arg.as(:oneline),
                                  "configured-flow-control" (
                                      c(
                                          "rx-buffers" (
                                            ("on" | "off")
                                          ),
                                          "tx-buffers" (
                                            ("on" | "off")
                                          )
                                      )
                                  ),
                                  "load-balance" (
                                    aggregate_load_balance
                                  ),
                                  "bfd-liveness-detection" (
                                      c(
                                          "version" (
                                            ("0" | "1" | "automatic")
                                          ),
                                          "minimum-interval" arg,
                                          "minimum-transmit-interval" arg,
                                          "minimum-receive-interval" arg,
                                          "multiplier" arg,
                                          c(
                                            "no-adaptation"
                                          ),
                                          "transmit-interval" (
                                              c(
                                                  "minimum-interval" arg,
                                                  "threshold" arg
                                              )
                                          ),
                                          "detection-time" (
                                              c(
                                                  "threshold" arg
                                              )
                                          ),
                                          "authentication" (
                                              c(
                                                  "key-chain" arg,
                                                  "algorithm" (
                                                    ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                                  ),
                                                  "loose-check"
                                              )
                                          ),
                                          "neighbor" (
                                            ipaddr
                                          ),
                                          "local-address" (
                                            ipaddr
                                          ),
                                          "holddown-interval" arg
                                      )
                                  ),
                                  "minimum-links" arg,
                                  "minimum-bandwidth" (
                                      c(
                                          "bw-value" arg,
                                          "bw-unit" (
                                            ("bps" | "kbps" | "mbps" | "gbps")
                                          )
                                      )
                                  ),
                                  "targeted-options" (
                                      c(
                                          "type" (
                                            ("auto" | "manual")
                                          ),
                                          c(
                                            "logical-interface-fpc-redundancy",
                                            "logical-interface-chassis-redundancy"
                                          ),
                                          "rebalance-periodic" (
                                              c(
                                                  "start-time" (
                                                    time
                                                  ),
                                                  "interval" arg
                                              )
                                          ),
                                          "rebalance-subscriber-granularity" arg
                                      )
                                  ),
                                  c(
                                    "logical-interface-fpc-redundancy",
                                    "logical-interface-chassis-redundancy"
                                  ),
                                  "rebalance-periodic" (
                                      c(
                                          "start-time" (
                                            time
                                          ),
                                          "interval" arg
                                      )
                                  ),
                                  "pad-to-minimum-frame-size",
                                  "link-speed" (
                                    ("10m" | "100m" | "1g" | "8g" | "10g" | "25g" | "40g" | "50g" | "80g" | "100g" | "oc192" | "mixed")
                                  ),
                                  "local-bias" (
                                      c(
                                          "disable"
                                      )
                                  ),
                                  "local-minimum-links-threshold" arg,
                                  "resilient-hash",
                                  "lacp" (
                                      c(
                                          c(
                                            "active",
                                            "passive"
                                          ),
                                          "periodic" (
                                            ("fast" | "slow")
                                          ),
                                          "fast-failover",
                                          "link-protection" (
                                              c(
                                                  "disable",
                                                  c(
                                                    "revertive",
                                                    "non-revertive"
                                                  )
                                              )
                                          ),
                                          "accept-data",
                                          "sync-reset" (
                                            ("disable" | "enable")
                                          ),
                                          "system-priority" arg,
                                          "system-id" (
                                            mac_addr
                                          ),
                                          "admin-key" arg,
                                          "hold-time" (
                                              c(
                                                  "up" arg
                                              )
                                          ).as(:oneline),
                                          "aggregate-wait-time" arg,
                                          "force-up"
                                      )
                                  ),
                                  "link-protection-sub-group" arg (
                                      c(
                                          c(
                                            "primary",
                                            "backup"
                                          )
                                      )
                                  ),
                                  "ethernet-switch-profile" (
                                      c(
                                          "tag-protocol-id" arg,
                                          "storm-control" (
                                              c(
                                                  arg
                                              )
                                          ),
                                          "mac-learn-enable"
                                      )
                                  ),
                                  "mc-ae" (
                                      c(
                                          "mc-ae-id" arg,
                                          "redundancy-group" arg,
                                          "chassis-id" arg,
                                          "mode" (
                                            ("active-standby" | "active-active")
                                          ),
                                          "status-control" (
                                            ("active" | "standby")
                                          ),
                                          "switchover-mode" (
                                            ("revertive" | "non-revertive")
                                          ),
                                          "revert-time" arg,
                                          "init-delay-time" arg,
                                          "recovery-delay-time" arg,
                                          "enhanced-convergence",
                                          "events" (
                                              c(
                                                  "iccp-peer-down" (
                                                      c(
                                                          "force-icl-down",
                                                          "prefer-status-control-active"
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "es-options" (
                              c(
                                  "backup-interface" (
                                    interface_device
                                  )
                              )
                          ),
                          "dsl-options" (
                              c(
                                  "operating-mode" (
                                    ("auto" | "ansi-dmt" | "itu-dmt" | "etsi" | "itu-annexb-ur2" | "itu-annexb-non-ur2" | "itu-dmt-bis" | "adsl2plus" | "annexm-itu-dmt-bis" | "annexm-adsl2plus")
                                  )
                              )
                          ),
                          "vdsl-options" (
                              c(
                                  "vdsl-profile" (
                                    ("auto" | "8a" | "8b" | "8c" | "8d" | "12a" | "12b" | "17a")
                                  ),
                                  "sra" (
                                    ("enable" | "disable")
                                  ),
                                  "v43" (
                                    ("enable" | "disable")
                                  )
                              )
                          ),
                          "shdsl-options" (
                              c(
                                  "annex" (
                                    ("annex-a" | "annex-b" | "annex-f" | "annex-g" | "annex-auto")
                                  ),
                                  "line-rate" (
                                    ("auto" | arg)
                                  ),
                                  "loopback" (
                                    ("local" | "remote")
                                  ),
                                  "snr-margin" (
                                      c(
                                          "current" (
                                            ("disable" | arg)
                                          ),
                                          "snext" (
                                            ("disable" | arg)
                                          )
                                      )
                                  )
                              )
                          ),
                          "data-input" (
                              c(
                                  c(
                                    "system",
                                    "interface" (
                                      interface_device
                                    )
                                  )
                              )
                          ),
                          "switch-options" (
                              c(
                                  "switch-port" arg (
                                      c(
                                          "auto-negotiation",
                                          "no-auto-negotiation",
                                          "link-mode" (
                                            ("half-duplex" | "full-duplex")
                                          ),
                                          "speed" (
                                            ("10m" | "100m" | "1g")
                                          ),
                                          "vlan-id" arg,
                                          "cascade-port"
                                      )
                                  )
                              )
                          ),
                          "container-options" (
                              c(
                                  "container-type" (
                                      c(
                                          c(
                                            "aps" (
                                              aps_type
                                            )
                                          )
                                      )
                                  ),
                                  "member-interface-type" (
                                      c(
                                          c(
                                            "sonet" (
                                                c(
                                                    "member-interface-speed" (
                                                      ("oc3" | "oc12" | "oc48" | "oc192" | "oc768" | "mixed")
                                                    )
                                                )
                                            ),
                                            "atm" (
                                                c(
                                                    "member-interface-speed" (
                                                      ("oc3" | "oc12" | "oc48")
                                                    )
                                                )
                                            ),
                                            "channelized-sonet" (
                                                c(
                                                    "member-interface-speed" (
                                                      ("coc3" | "coc12" | "coc48" | "coc192" | "coc768")
                                                    )
                                                )
                                            ),
                                            "channelized-sdh" (
                                                c(
                                                    "member-interface-speed" (
                                                      ("cstm1" | "cstm4" | "cstm16" | "coc64" | "cstm256")
                                                    )
                                                )
                                            )
                                          )
                                      )
                                  ),
                                  "redundancy" (
                                      c(
                                          "hold-time" (
                                              c(
                                                  "up" arg,
                                                  "down" arg
                                              )
                                          ).as(:oneline)
                                      )
                                  ),
                                  "container-list" (
                                    interface_device
                                  ),
                                  c(
                                      "primary",
                                      "standby"
                                  ),
                                  "fast-aps",
                                  "allow-configuration-override"
                              )
                          ),
                          "layer2-policer" (
                              c(
                                  c(
                                    "input-policer" arg,
                                    "input-hierarchical-policer" arg
                                  )
                              )
                          ),
                          "unit" (("$junos-underlying-interface-unit" | "$junos-interface-unit" | arg)) (
                              c(
                                  "policer-overhead" (
                                      c(
                                            arg,
                                          "ingress" arg,
                                          "egress" arg
                                      )
                                  ),
                                  "alias" arg,
                                  "enhanced-convergence",
                                  "proxy-macip-advertisement",
                                  "peer-psd" (
                                      c(
                                          arg
                                      )
                                  ).as(:oneline),
                                  "peer-interface" (
                                      c(
                                            interface_unit
                                      )
                                  ),
                                  "interface-shared-with" (
                                      c(
                                          arg
                                      )
                                  ),
                                    ("disable"),
                                  "passive-monitor-mode",
                                  "per-session-scheduler",
                                  "account-layer2-overhead" (
                                      c(
                                            arg,
                                          "ingress" arg,
                                          "egress" arg
                                      )
                                  ),
                                  "forwarding-class-accounting" (
                                      c(
                                          "direction" (
                                            ("ingress" | "egress" | "both")
                                          ),
                                          "enhanced" (
                                              c(
                                                  "traffic-type" (
                                                    ("unicast-statistics" | "multicast-statistics")
                                                  ),
                                                  "family" (
                                                    ("inet" | "inet6" | "both")
                                                  ),
                                                  "direction" (
                                                    ("ingress" | "egress" | "both")
                                                  ),
                                                  "overhead-bytes" arg
                                              )
                                          )
                                      )
                                  ),
                                  "clear-dont-fragment-bit",
                                  "packet-inject-enable",
                                  "reassemble-packets",
                                  "services-options",
                                  "rpm" (
                                      c(
                                          c(
                                            c(
                                              "client",
                                              "server"
                                            ),
                                            "twamp-server",
                                            "twamp-client"
                                          )
                                      )
                                  ),
                                  "description" arg,
                                  "metadata" arg,
                                  "dial-options" (
                                      c(
                                          c(
                                            "l2tp-interface-id" arg,
                                            "ipsec-interface-id" arg
                                          ),
                                          c(
                                            "dedicated",
                                            "shared"
                                          )
                                      )
                                  ),
                                  "actual-transit-statistics",
                                  "demux-source" (
                                        (("inet" | "inet6"))
                                  ),
                                  "demux-destination" (
                                        (("inet" | "inet6"))
                                  ),
                                  "encapsulation" (
                                    ("atm-nlpid" | "atm-cisco-nlpid" | "atm-snap" | "atm-vc-mux" | "atm-ccc-vc-mux" | "atm-tcc-vc-mux" | "atm-tcc-snap" | "atm-ccc-cell-relay" | "vlan-vci-ccc" | "ether-over-atm-llc" | "ether-vpls-over-atm-llc" | "ppp-over-ether-over-atm-llc" | "ppp-over-ether" | "atm-ppp-vc-mux" | "atm-ppp-llc" | "atm-mlppp-llc" | "frame-relay-ppp" | "frame-relay-ccc" | "frame-relay" | "frame-relay-tcc" | "frame-relay-ether-type" | "frame-relay-ether-type-tcc" | "ether-vpls-fr" | "vlan-ccc" | "ethernet-ccc" | "vlan-vpls" | "vlan-bridge" | "dix" | "ethernet" | "ethernet-vpls" | "ethernet-bridge" | "vlan" | "vlan-tcc" | "multilink-ppp" | "multilink-frame-relay-end-to-end" | "ppp-ccc")
                                  ),
                                  "gre",
                                  "mtu" arg,
                                  c(
                                    "point-to-point",
                                    "multipoint"
                                  ),
                                  "bandwidth" arg,
                                  "global-layer2-domainid" arg,
                                  "radio-router" (
                                    dynamic_ifbw_parms_type
                                  ),
                                  "traps",
                                  "no-traps",
                                  "routing-services",
                                  "no-routing-services",
                                  "arp-resp" (
                                      c(
                                          c(
                                            "unrestricted",
                                            "restricted"
                                          )
                                      )
                                  ).as(:oneline),
                                  "proxy-arp" (
                                      c(
                                          c(
                                            "unrestricted",
                                            "restricted"
                                          )
                                      )
                                  ).as(:oneline),
                                  c(
                                    "vlan-id" (
                                      ("none" | arg)
                                    ),
                                    "vlan-id-range" arg,
                                    "inner-vlan-id-swap-ranges" arg,
                                    "vlan-id-list" arg,
                                    "vlan-tag" arg,
                                    "vlan-tags" (
                                        c(
                                            "outer" (
                                              ("$junos-stacked-vlan-id" | "$junos-vlan-id" | arg)
                                            ),
                                            c(
                                              "inner" (
                                                ("$junos-vlan-id" | arg)
                                              ),
                                              "inner-range" arg,
                                              "inner-list" arg
                                            )
                                        )
                                    ).as(:oneline)
                                  ),
                                  "native-inner-vlan-id" arg,
                                  "inner-vlan-id-range" (
                                      c(
                                          "start" arg,
                                          "end" arg
                                      )
                                  ).as(:oneline),
                                  "accept-source-mac" (
                                      c(
                                          "mac-address" (
                                            mac_list
                                          )
                                      )
                                  ),
                                  "input-vlan-map" (
                                    vlan_map
                                  ),
                                  "output-vlan-map" (
                                    vlan_map
                                  ),
                                  "swap-by-poppush",
                                  "receive-lsp" arg,
                                  "transmit-lsp" arg,
                                  "dlci" arg,
                                  "multicast-dlci" arg,
                                  c(
                                    "vci" (
                                      atm_vci
                                    ),
                                    "allow-any-vci",
                                    "vpi" arg,
                                    "trunk-id" arg
                                  ),
                                  "no-vpivci-swapping",
                                  c(
                                    "psn-vci" (
                                      atm_vci
                                    ),
                                    "psn-vpi" arg
                                  ),
                                  "atm-l2circuit-mode" (
                                      c(
                                          c(
                                            "cell",
                                            "aal5"
                                          )
                                      )
                                  ).as(:oneline),
                                  "vci-range" (
                                      c(
                                          "start" arg,
                                          "end" arg
                                      )
                                  ).as(:oneline),
                                  "trunk-bandwidth" arg,
                                  "multicast-vci" (
                                    atm_vci
                                  ),
                                  "shaping" (
                                    dcd_shaping_config
                                  ),
                                  "oam-period" (
                                      c(
                                          c(
                                              arg,
                                            "disable".as(:oneline)
                                          )
                                      )
                                  ).as(:oneline),
                                  "oam-liveness" (
                                      c(
                                          "up-count" arg,
                                          "down-count" arg
                                      )
                                  ),
                                  "ppp-options" (
                                    ppp_options_type
                                  ),
                                  "pppoe-options" (
                                    pppoe_options_type
                                  ),
                                  "pppoe-underlying-options" (
                                    pppoe_underlying_options_type
                                  ),
                                  "advisory-options" (
                                    advisory_options_type
                                  ),
                                  "auto-configure" (
                                    auto_configure_vlan_type
                                  ),
                                  "demux-options" (
                                    demux_options_type
                                  ),
                                  "targeted-distribution" (
                                      c(
                                          "primary-list" arg,
                                          "backup-list" arg,
                                          "standby-list" arg
                                      )
                                  ),
                                  "targeted-options" (
                                      c(
                                          "primary" (
                                            interface_device
                                          ),
                                          "backup" (
                                            interface_device
                                          ),
                                          "group" arg
                                      )
                                  ),
                                  c(
                                    "keepalives" (
                                      keepalives_type
                                    ).as(:oneline),
                                    "no-keepalives"
                                  ),
                                  "inverse-arp",
                                  "transmit-weight" arg,
                                  "epd-threshold" (
                                    epd_threshold_config
                                  ).as(:oneline),
                                  "cell-bundle-size" arg,
                                  "cell-bundle-timeout" arg,
                                  "plp-to-clp",
                                  "atm-scheduler-map" arg,
                                  "mrru" arg,
                                  "short-sequence",
                                  "fragment-threshold" arg,
                                  "drop-timeout" arg,
                                  "disable-mlppp-inner-ppp-pfc",
                                  "minimum-links" arg,
                                  "multilink-max-classes" arg,
                                  "compression" (
                                      c(
                                          "rtp" (
                                              c(
                                                  "f-max-period" arg,
                                                  "queues" (
                                                    ("q0" | "q1" | "q2" | "q3")
                                                  ),
                                                  "port" (
                                                      c(
                                                          "minimum" arg,
                                                          "maximum" arg
                                                      )
                                                  ).as(:oneline),
                                                  "maximum-contexts" (
                                                      c(
                                                            arg
                                                      )
                                                  ).as(:oneline)
                                              )
                                          )
                                      )
                                  ),
                                  "interleave-fragments",
                                  "link-layer-overhead" (
                                    unsigned_float
                                  ),
                                  "accounting-profile" arg,
                                  "peer-unit" arg,
                                  "tunnel" (
                                      c(
                                          "source" (
                                            ipaddr
                                          ),
                                          "destination" (
                                            ipaddr
                                          ),
                                          "key" arg,
                                          "backup-destination" (
                                            ipaddr
                                          ),
                                          c(
                                            "allow-fragmentation",
                                            "do-not-fragment"
                                          ),
                                          "ttl" arg,
                                          "traffic-class" arg,
                                          "flow-label" arg,
                                          "path-mtu-discovery",
                                          "no-path-mtu-discovery",
                                          "routing-instance" (
                                              c(
                                                  "destination" arg
                                              )
                                          )
                                      )
                                  ),
                                  "compression-device" (
                                    interface_unit
                                  ),
                                  "atm-policer" (
                                      c(
                                          "input-atm-policer" arg
                                      )
                                  ),
                                  "layer2-policer" (
                                      c(
                                          c(
                                            "input-policer" arg,
                                            "input-hierarchical-policer" arg,
                                            "input-three-color" arg
                                          ),
                                          c(
                                            "output-policer" (
                                              ("$junos-layer2-output-policer" | arg)
                                            ),
                                            "output-three-color" (
                                              ("$junos-layer2-output-policer" | arg)
                                            )
                                          )
                                      )
                                  ),
                                  "filter" (
                                      c(
                                          c(
                                            "input" (
                                                c(
                                                    arg,
                                                    "shared-name" arg,
                                                    "precedence" arg
                                                )
                                            ).as(:oneline)
                                          ),
                                          c(
                                            "output" (
                                                c(
                                                    arg,
                                                    "shared-name" arg,
                                                    "precedence" arg
                                                )
                                            ).as(:oneline)
                                          )
                                      )
                                  ),
                                  "multi-chassis-protection" (
                                    multi_chassis_protection_group_ifl
                                  ),
                                  "statistics",
                                  "esi" (
                                      c(
                                            esi,
                                          c(
                                            "single-active",
                                            "all-active"
                                          )
                                      )
                                  ),
                                  "virtual-gateway-esi" (
                                      c(
                                            esi,
                                          c(
                                            "single-active",
                                            "all-active"
                                          )
                                      )
                                  ),
                                  "service" (
                                      c(
                                          "pcef" arg (
                                              c(
                                                  "activate-all",
                                                  "activate" arg
                                              )
                                          )
                                      )
                                  ),
                                  "family" (
                                      c(
                                          "inet" (
                                              c(
                                                  "dhcp" (
                                                    dhcp_client_type
                                                  ),
                                                  "targeted-broadcast" (
                                                      c(
                                                          c(
                                                            "forward-and-send-to-re",
                                                            "forward-only"
                                                          )
                                                      )
                                                  ),
                                                  "destination-class-usage",
                                                  "transit-options-packets",
                                                  "transit-ttl-exceeded",
                                                  "receive-options-packets",
                                                  "receive-ttl-exceeded",
                                                  "accounting" (
                                                      c(
                                                          "source-class-usage" (
                                                              c(
                                                                  "input",
                                                                  "output"
                                                              )
                                                          ),
                                                          "destination-class-usage"
                                                      )
                                                  ),
                                                  "mac-validate" (
                                                    ("strict" | "loose")
                                                  ),
                                                  "rpf-check" (
                                                      c(
                                                          "fail-filter" arg,
                                                          "mode" (
                                                              c(
                                                                  "loose"
                                                              )
                                                          ).as(:oneline)
                                                      )
                                                  ),
                                                  "mtu" arg,
                                                  "arp-max-cache" arg,
                                                  "arp-new-hold-limit" arg,
                                                  "tcp-mss" arg,
                                                  "no-redirects",
                                                  "no-neighbor-learn",
                                                  "unconditional-src-learn",
                                                  "multicast-only",
                                                  "primary",
                                                  "ipsec-sa" arg,
                                                  "allow-filter-on-re",
                                                  "demux-source" ("$junos-subscriber-ip-address" | arg),
                                                  "demux-destination" ("$junos-subscriber-ip-address" | arg),
                                                  "filter" (
                                                      c(
                                                          c(
                                                            "input" (
                                                                c(
                                                                    arg,
                                                                    "shared-name" arg,
                                                                    "precedence" arg
                                                                )
                                                            ).as(:oneline),
                                                            "input-list" arg
                                                          ),
                                                          c(
                                                            "output" (
                                                                c(
                                                                    arg,
                                                                    "shared-name" arg,
                                                                    "precedence" arg
                                                                )
                                                            ).as(:oneline),
                                                            "output-list" arg
                                                          ),
                                                          "adf" (
                                                              c(
                                                                  "rule" arg,
                                                                  "counter",
                                                                  "input-precedence" arg,
                                                                  "not-mandatory",
                                                                  "output-precedence" arg
                                                              )
                                                          ),
                                                          "group" arg
                                                      )
                                                  ),
                                                  "ingress-queuing-filter" (
                                                      c(
                                                          arg
                                                      )
                                                  ).as(:oneline),
                                                  "simple-filter" (
                                                      c(
                                                          "input" arg
                                                      )
                                                  ),
                                                  "input-hierarchical-policer" arg,
                                                  "policer" (
                                                      c(
                                                          "arp" arg,
                                                          "input" arg,
                                                          "output" arg
                                                      )
                                                  ),
                                                  "sampling" (
                                                      c(
                                                          "input",
                                                          "output"
                                                      )
                                                  ),
                                                  "service" (
                                                      c(
                                                          "input" (
                                                              c(
                                                                  "service-set" arg (
                                                                      c(
                                                                          "service-filter" arg
                                                                      )
                                                                  ),
                                                                  "post-service-filter" arg
                                                              )
                                                          ),
                                                          "output" (
                                                              c(
                                                                  "service-set" arg (
                                                                      c(
                                                                          "service-filter" arg
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  ),
                                                  "next-hop-tunnel" arg (
                                                      c(
                                                          "ipsec-vpn" arg
                                                      )
                                                  ),
                                                  "address" arg (
                                                      c(
                                                          "destination" (
                                                            ipv4addr
                                                          ),
                                                          "destination-profile" arg,
                                                          "broadcast" (
                                                            ipv4addr
                                                          ),
                                                          "primary",
                                                          "preferred",
                                                          "master-only",
                                                          "multipoint-destination" arg (
                                                              c(
                                                                  c(
                                                                    "dlci" arg,
                                                                    "vci" (
                                                                      atm_vci
                                                                    )
                                                                  ),
                                                                  "shaping" (
                                                                    dcd_shaping_config
                                                                  ),
                                                                  "oam-period" (
                                                                      c(
                                                                          c(
                                                                              arg,
                                                                            "disable".as(:oneline)
                                                                          )
                                                                      )
                                                                  ).as(:oneline),
                                                                  "oam-liveness" (
                                                                      c(
                                                                          "up-count" arg,
                                                                          "down-count" arg
                                                                      )
                                                                  ),
                                                                  "inverse-arp",
                                                                  "transmit-weight" arg,
                                                                  "epd-threshold" (
                                                                    epd_threshold_config
                                                                  ).as(:oneline)
                                                              )
                                                          ),
                                                          "arp" arg (
                                                              c(
                                                                  "l2-interface" (
                                                                    interface_name
                                                                  ),
                                                                  c(
                                                                    "mac" (
                                                                      mac_unicast
                                                                    ),
                                                                    "multicast-mac" (
                                                                      mac_multicast
                                                                    )
                                                                  ),
                                                                  "publish"
                                                              )
                                                          ).as(:oneline),
                                                          "web-authentication" (
                                                              c(
                                                                  "http",
                                                                  "https",
                                                                  "redirect-to-https"
                                                              )
                                                          ),
                                                          "vrrp-group" (
                                                            vrrp_group
                                                          ),
                                                          "virtual-gateway-address" (
                                                            ipv4addr
                                                          )
                                                      )
                                                  ),
                                                  "unnumbered-address" (
                                                      c(
                                                            interface_unit,
                                                          "preferred-source-address" (
                                                            ("$junos-preferred-source-address" | arg)
                                                          ),
                                                          "destination" (
                                                            ipv4addr
                                                          ),
                                                          "destination-profile" arg
                                                      )
                                                  ).as(:oneline),
                                                  "location-pool-address" (
                                                      c(
                                                            arg
                                                      )
                                                  ),
                                                  "negotiate-address"
                                              )
                                          ),
                                          "iso" (
                                              c(
                                                  "address" arg,
                                                  "mtu" arg
                                              )
                                          ),
                                          "inet6" (
                                              c(
                                                  "dhcpv6-client" (
                                                      c(
                                                          "client-type" (
                                                            ("stateful" | "autoconfig")
                                                          ),
                                                          "client-ia-type" (("ia-na" | "ia-pd")),
                                                          "rapid-commit",
                                                          "client-identifier" (
                                                              c(
                                                                  "duid-type" (
                                                                    ("duid-llt" | "vendor" | "duid-ll")
                                                                  )
                                                              )
                                                          ).as(:oneline),
                                                          "req-option" (("dns-server" | "domain" | "ntp-server" | "time-zone" | "sip-server" | "sip-domain" | "nis-server" | "nis-domain" | "fqdn" | "vendor-spec")),
                                                          "retransmission-attempt" arg,
                                                          "no-dns-propagation",
                                                          "update-router-advertisement" (
                                                              c(
                                                                  "interface" arg (
                                                                      c(
                                                                          "managed-configuration",
                                                                          "no-managed-configuration",
                                                                          "other-stateful-configuration",
                                                                          "no-other-stateful-configuration",
                                                                          "max-advertisement-interval" arg,
                                                                          "min-advertisement-interval" arg
                                                                      )
                                                                  )
                                                              )
                                                          ),
                                                          "update-server"
                                                      )
                                                  ),
                                                  "rpf-check" (
                                                      c(
                                                          "fail-filter" arg,
                                                          "mode" (
                                                              c(
                                                                  "loose"
                                                              )
                                                          ).as(:oneline)
                                                      )
                                                  ),
                                                  "accounting" (
                                                      c(
                                                          "source-class-usage" (
                                                              c(
                                                                  "input",
                                                                  "output"
                                                              )
                                                          ),
                                                          "destination-class-usage"
                                                      )
                                                  ),
                                                  "mtu" arg,
                                                  "tcp-mss" arg,
                                                  "nd6-stale-time" arg,
                                                  "no-neighbor-learn",
                                                  "nd6-max-cache" arg,
                                                  "nd6-new-hold-limit" arg,
                                                  "no-redirects",
                                                  "allow-filter-on-re",
                                                  "filter" (
                                                      c(
                                                          c(
                                                            "input" (
                                                                c(
                                                                    arg,
                                                                    "shared-name" arg,
                                                                    "precedence" arg
                                                                )
                                                            ).as(:oneline),
                                                            "input-list" arg
                                                          ),
                                                          c(
                                                            "output" (
                                                                c(
                                                                    arg,
                                                                    "shared-name" arg,
                                                                    "precedence" arg
                                                                )
                                                            ).as(:oneline),
                                                            "output-list" arg
                                                          ),
                                                          "adf" (
                                                              c(
                                                                  "rule" arg,
                                                                  "counter",
                                                                  "input-precedence" arg,
                                                                  "not-mandatory",
                                                                  "output-precedence" arg
                                                              )
                                                          ),
                                                          "group" arg
                                                      )
                                                  ),
                                                  "ingress-queuing-filter" (
                                                      c(
                                                          arg
                                                      )
                                                  ).as(:oneline),
                                                  "input-hierarchical-policer" arg,
                                                  "policer" (
                                                      c(
                                                          "input" arg,
                                                          "output" arg
                                                      )
                                                  ),
                                                  "sampling" (
                                                      c(
                                                          "input",
                                                          "output"
                                                      )
                                                  ),
                                                  "service" (
                                                      c(
                                                          "input" (
                                                              c(
                                                                  "service-set" arg (
                                                                      c(
                                                                          "service-filter" arg
                                                                      )
                                                                  ),
                                                                  "post-service-filter" arg
                                                              )
                                                          ),
                                                          "output" (
                                                              c(
                                                                  "service-set" arg (
                                                                      c(
                                                                          "service-filter" arg
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  ),
                                                  "address" arg (
                                                      c(
                                                          "destination" (
                                                            ipv6addr
                                                          ),
                                                          "eui-64",
                                                          "primary",
                                                          "preferred",
                                                          "master-only",
                                                          "ndp" arg (
                                                              c(
                                                                  "l2-interface" (
                                                                    interface_name
                                                                  ),
                                                                  c(
                                                                    "mac" (
                                                                      mac_unicast
                                                                    ),
                                                                    "multicast-mac" (
                                                                      mac_multicast
                                                                    )
                                                                  ),
                                                                  "publish"
                                                              )
                                                          ).as(:oneline),
                                                          "vrrp-inet6-group" (
                                                            vrrp_group
                                                          ),
                                                          "web-authentication" (
                                                              c(
                                                                  "http",
                                                                  "https",
                                                                  "redirect-to-https"
                                                              )
                                                          ),
                                                          "virtual-gateway-address" (
                                                            ipv6addr
                                                          ),
                                                          "subnet-router-anycast"
                                                      )
                                                  ),
                                                  "demux-source" ("$junos-subscriber-ipv6-address" | arg | "$junos-subscriber-ipv6-multi-address"),
                                                  "demux-destination" ("$junos-subscriber-ipv6-address" | arg),
                                                  "unnumbered-address" (
                                                      c(
                                                            interface_unit,
                                                          "preferred-source-address" (
                                                            ("$junos-preferred-source-ipv6-address" | arg)
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "dad-disable",
                                                  "no-dad-disable"
                                              )
                                          ),
                                          "mpls" (
                                              c(
                                                  "mtu" arg,
                                                  "maximum-labels" arg,
                                                  "filter" (
                                                      c(
                                                          c(
                                                            "input" arg,
                                                            "input-list" arg
                                                          ),
                                                          c(
                                                            "output" arg,
                                                            "output-list" arg
                                                          ),
                                                          "group" arg
                                                      )
                                                  ),
                                                  "ingress-queuing-filter" (
                                                      c(
                                                          arg
                                                      )
                                                  ).as(:oneline),
                                                  "input-hierarchical-policer" arg,
                                                  "policer" (
                                                      c(
                                                          "input" arg,
                                                          "output" arg
                                                      )
                                                  )
                                              )
                                          ),
                                          "mlppp" (
                                              c(
                                                  "bundle" (
                                                    ("$junos-bundle-interface-name" | arg)
                                                  ),
                                                  c(
                                                    "service-interface" (
                                                      interface_device
                                                    ),
                                                    "service-device-pool" arg
                                                  ),
                                                  "dynamic-profile" arg
                                              )
                                          ),
                                          "mlfr-end-to-end" (
                                              c(
                                                  "bundle" (
                                                    interface_unit
                                                  )
                                              )
                                          ),
                                          "mlfr-uni-nni" (
                                              c(
                                                  "bundle" (
                                                    interface_unit
                                                  )
                                              )
                                          ),
                                          "ccc" (
                                              c(
                                                  "mtu" arg,
                                                  "filter" (
                                                      c(
                                                          c(
                                                            "input" arg,
                                                            "input-list" arg
                                                          ),
                                                          c(
                                                            "output" arg,
                                                            "output-list" arg
                                                          ),
                                                          "group" arg
                                                      )
                                                  ),
                                                  "ingress-queuing-filter" (
                                                      c(
                                                          arg
                                                      )
                                                  ).as(:oneline),
                                                  "policer" (
                                                      c(
                                                          "input" arg,
                                                          "output" arg
                                                      )
                                                  ),
                                                  "translate-fecn-and-becn",
                                                  c(
                                                    "translate-discard-eligible",
                                                    "translate-plp-control-word-de"
                                                  ),
                                                  "keep-address-and-control"
                                              )
                                          ),
                                          "tcc" (
                                              c(
                                                  "policer" (
                                                      c(
                                                          "input" arg,
                                                          "output" arg
                                                      )
                                                  ),
                                                  "proxy" (
                                                      c(
                                                          "inet-address" (
                                                            ipv4addr
                                                          )
                                                      )
                                                  ),
                                                  "remote" (
                                                      c(
                                                          "inet-address" (
                                                            ipv4addr
                                                          ),
                                                          "mac-address" (
                                                            mac_addr
                                                          )
                                                      )
                                                  ),
                                                  "protocols" (
                                                    ("mpls" | "inet" | "iso")
                                                  )
                                              )
                                          ),
                                          "vpls" (
                                              c(
                                                  "core-facing",
                                                  "filter" (
                                                      c(
                                                          c(
                                                            "input" (
                                                                c(
                                                                    arg,
                                                                    "shared-name" arg,
                                                                    "precedence" arg
                                                                )
                                                            ).as(:oneline),
                                                            "input-list" arg
                                                          ),
                                                          c(
                                                            "output" (
                                                                c(
                                                                    arg,
                                                                    "shared-name" arg,
                                                                    "precedence" arg
                                                                )
                                                            ).as(:oneline),
                                                            "output-list" arg
                                                          ),
                                                          "adf" (
                                                              c(
                                                                  "rule" arg,
                                                                  "counter",
                                                                  "input-precedence" arg,
                                                                  "not-mandatory",
                                                                  "output-precedence" arg
                                                              )
                                                          ),
                                                          "group" arg
                                                      )
                                                  ),
                                                  "ingress-queuing-filter" (
                                                      c(
                                                          arg
                                                      )
                                                  ).as(:oneline),
                                                  "policer" (
                                                      c(
                                                          "input" arg,
                                                          "output" arg
                                                      )
                                                  )
                                              )
                                          ),
                                          "bridge" (
                                              c(
                                                  "core-facing",
                                                  "filter" (
                                                      c(
                                                          c(
                                                            "input" (
                                                                c(
                                                                    arg,
                                                                    "shared-name" arg,
                                                                    "precedence" arg
                                                                )
                                                            ).as(:oneline),
                                                            "input-list" arg
                                                          ),
                                                          c(
                                                            "output" (
                                                                c(
                                                                    arg,
                                                                    "shared-name" arg,
                                                                    "precedence" arg
                                                                )
                                                            ).as(:oneline),
                                                            "output-list" arg
                                                          ),
                                                          "adf" (
                                                              c(
                                                                  "rule" arg,
                                                                  "counter",
                                                                  "input-precedence" arg,
                                                                  "not-mandatory",
                                                                  "output-precedence" arg
                                                              )
                                                          ),
                                                          "group" arg
                                                      )
                                                  ),
                                                  "ingress-queuing-filter" (
                                                      c(
                                                          arg
                                                      )
                                                  ).as(:oneline),
                                                  "policer" (
                                                      c(
                                                          "input" arg,
                                                          "output" arg
                                                      )
                                                  ),
                                                  "interface-mode" (
                                                    ("access" | "trunk")
                                                  ),
                                                  "vlan-auto-sense",
                                                  "bridge-domain-type" (
                                                    ("svlan" | "bvlan")
                                                  ),
                                                  "inter-switch-link",
                                                  c(
                                                    "vlan-id" arg,
                                                    "vlan-id-list" arg,
                                                    "inner-vlan-id-list" arg
                                                  ),
                                                  "vlan-rewrite" (
                                                      c(
                                                          "translate" arg (
                                                              c(
                                                                    arg
                                                              )
                                                          ).as(:oneline)
                                                      )
                                                  ),
                                                  c(
                                                    "isid-list" (
                                                      ("all-service-groups" | "all")
                                                    )
                                                  ),
                                                  "storm-control" (
                                                      c(
                                                          arg
                                                      )
                                                  ),
                                                  "recovery-timeout" (
                                                      c(
                                                            arg
                                                      )
                                                  ).as(:oneline)
                                              )
                                          ),
                                          "ethernet-switching" (
                                            ethernet_switching_type
                                          ),
                                          "fibre-channel" (
                                            fibre_channel_type
                                          ),
                                          "pppoe" (
                                            pppoe_underlying_options_type
                                          ),
                                          "any" (
                                              c(
                                                  "filter" (
                                                      c(
                                                          "input" arg,
                                                          "group" arg
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "service-domain" (
                                    ("inside" | "outside")
                                  ),
                                  "copy-tos-to-outer-ip-header",
                                  "copy-tos-to-outer-ip-header-transit",
                                  "load-balancing-options" (
                                      c(
                                          "preferred-active" (
                                            interface_device
                                          ),
                                          "hash-keys" (
                                              c(
                                                  "ingress-key" (
                                                        (("source-ip" | "destination-ip" | "protocol" | "iif"))
                                                  ),
                                                  "egress-key" (
                                                        (("source-ip" | "destination-ip" | "protocol" | "oif"))
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "mac" (
                                    mac_unicast
                                  ),
                                  "virtual-gateway-v4-mac" (
                                    mac_unicast
                                  ),
                                  "virtual-gateway-v6-mac" (
                                    mac_unicast
                                  ),
                                  "forwarding-options" (
                                      c(
                                          "load-balance-stateful" (
                                              c(
                                                  "per-flow",
                                                  "rebalance" arg,
                                                  "load-type" (
                                                    ("high" | "medium" | "low")
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "etree-ac-role" (
                                    ("root" | "leaf")
                                  )
                              )
                          ),
                          "no-partition" (
                              c(
                                  "interface-type" (
                                    ("e1" | "t1" | "at" | "t3" | "e3" | "ct3" | "so" | "cau4")
                                  )
                              )
                          ).as(:oneline),
                          "partition" arg (
                              c(
                                  "oc-slice" arg,
                                  "timeslots" arg,
                                  "interface-type" (
                                    ("ds" | "e1" | "t1" | "at" | "ct1" | "ce1" | "t3" | "ct3" | "e3" | "so" | "coc1" | "cau4" | "dc" | "bc")
                                  )
                              )
                          ).as(:oneline),
                          "radius-options" (
                            radius_options_vlan_type
                          )
                      )
                  ),
                    interfaces_type
              )
          ),
          "multi-chassis" (
              c(
                  "mc-lag" (
                      c(
                          "consistency-check" (
                              c(
                                  "traceoptions" (
                                      c(
                                          "no-remote-trace",
                                          "file" (
                                              c(
                                                    arg,
                                                  "size" arg,
                                                  "files" arg,
                                                  "world-readable",
                                                  "no-world-readable",
                                                  "match" (
                                                    regular_expression
                                                  )
                                              )
                                          ).as(:oneline),
                                          "flag" (("error" | "event" | "packet" | "pipe" | "pipe-detail" | "all")).as(:oneline)
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "multi-chassis-protection" (
                    multi_chassis_protection_group
                  )
              )
          ),
          "jsrc-partition" (
              c(
                    arg
              )
          ).as(:oneline),
          "snmp" (
              c(
                  "system-name" arg,
                  "description" arg,
                  "location" arg,
                  "contact" arg,
                  "interface" (
                    interface_name
                  ),
                  "alarm-management" (
                      c(
                          "alarm-list-name" arg (
                              c(
                                  "alarm-id" arg (
                                      c(
                                          "alarm-state" arg (
                                              c(
                                                  "notification-id" arg,
                                                  "varbind-index" arg,
                                                  "varbind-value" arg,
                                                  "description" arg,
                                                  "varbind-subtree" arg,
                                                  "resource-prefix" arg
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "filter-interfaces" (
                      c(
                          "interfaces" arg,
                          "all-internal-interfaces"
                      )
                  ),
                  "if-count-with-filter-interfaces",
                  "filter-duplicates",
                  "nonvolatile" (
                      c(
                          "commit-delay" arg
                      )
                  ),
                  "v3" (
                      c(
                          "usm" (
                              c(
                                  "local-engine" (
                                      c(
                                          "user" (
                                            v3_user_config
                                          )
                                      )
                                  ),
                                  "remote-engine" arg (
                                      c(
                                          "user" (
                                            v3_user_config
                                          )
                                      )
                                  )
                              )
                          ),
                          "vacm" (
                              c(
                                  "security-to-group" (
                                      c(
                                          "security-model" (("usm" | "v1" | "v2c")) (
                                              c(
                                                  "security-name" arg (
                                                      c(
                                                          "group" arg
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "access" (
                                      c(
                                          "group" arg (
                                              c(
                                                  "default-context-prefix" (
                                                      c(
                                                          "security-model" (
                                                            security_model_access
                                                          )
                                                      )
                                                  ),
                                                  "context-prefix" arg (
                                                      c(
                                                          "security-model" (
                                                            security_model_access
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "target-address" arg (
                              c(
                                  "address" (
                                    ipaddr
                                  ),
                                  "port" arg,
                                  "timeout" arg,
                                  "retry-count" arg,
                                  "tag-list" arg,
                                  "address-mask" (
                                    ipaddr
                                  ),
                                  "routing-instance" arg,
                                  "logical-system" arg,
                                  "target-parameters" arg
                              )
                          ),
                          "target-parameters" arg (
                              c(
                                  "parameters" (
                                      c(
                                          "message-processing-model" (
                                            ("v1" | "v2c" | "v3")
                                          ),
                                          "security-model" (
                                            ("usm" | "v1" | "v2c")
                                          ),
                                          "security-level" (
                                            ("none" | "authentication" | "privacy")
                                          ),
                                          "security-name" arg
                                      )
                                  ),
                                  "notify-filter" (
                                      c(
                                            arg
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "notify" arg (
                              c(
                                  "type" (
                                    ("trap" | "inform")
                                  ),
                                  "tag" arg
                              )
                          ),
                          "notify-filter" arg (
                              c(
                                  "oid" arg (
                                      c(
                                          c(
                                            "include",
                                            "exclude"
                                          )
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "snmp-community" arg (
                              c(
                                  "community-name" (
                                    unreadable
                                  ),
                                  "security-name" arg,
                                  "context" arg,
                                  "tag" arg
                              )
                          )
                      )
                  ),
                  "proxy" arg (
                      c(
                          "device-name" arg,
                          c(
                            "version-v1" (
                              comm_object
                            ),
                            "version-v2c" (
                              comm_object
                            ),
                            "version-v3" (
                              sec_object
                            )
                          ),
                          "routing-instance" arg,
                          "logical-system" arg (
                              c(
                                  "routing-instance" arg
                              )
                          )
                      )
                  ),
                  "subagent" (
                      c(
                          "tcp" (
                              c(
                                  "routing-instance" (
                                      c(
                                          "default"
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "engine-id" (
                      c(
                          c(
                            "use-mac-address",
                            "use-default-ip-address",
                            "local" arg
                          )
                      )
                  ),
                  "access" (
                      c(
                          "user" arg (
                              c(
                                  "authentication-type" (
                                    ("none" | "md5" | "sha")
                                  ),
                                  "authentication-password" (
                                    unreadable
                                  ),
                                  "privacy-type" (
                                    ("none" | "des")
                                  ),
                                  "privacy-password" (
                                    unreadable
                                  ),
                                  "clients" arg (
                                      c(
                                          "restrict"
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "group" arg (
                              c(
                                  "user" arg,
                                  "model" (
                                    ("usm")
                                  )
                              )
                          ),
                          "context" arg (
                              c(
                                  "description" arg,
                                  "group" arg (
                                      c(
                                          "model" (
                                            ("usm")
                                          ),
                                          "security-level" (
                                            ("none" | "authentication" | "privacy")
                                          ),
                                          "read-view" arg,
                                          "write-view" arg
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "view" arg (
                      c(
                          "oid" arg (
                              c(
                                  c(
                                    "include",
                                    "exclude"
                                  )
                              )
                          ).as(:oneline)
                      )
                  ),
                  "client-list" arg (
                      c(
                            client_address_object
                      )
                  ),
                  "community" arg (
                      c(
                          "view" arg,
                          "authorization" (
                            ("read-only" | "read-write")
                          ),
                          c(
                            "client-list-name" arg,
                            "clients" arg (
                                c(
                                    "restrict"
                                )
                            ).as(:oneline)
                          ),
                          "routing-instances" arg (
                              c(
                                  c(
                                    "client-list-name" arg,
                                    "clients" arg (
                                        c(
                                            "restrict"
                                        )
                                    ).as(:oneline)
                                  )
                              )
                          ),
                          "routing-instance" arg (
                              c(
                                  c(
                                    "client-list-name" arg,
                                    "clients" arg (
                                        c(
                                            "restrict"
                                        )
                                    ).as(:oneline)
                                  )
                              )
                          ),
                          "logical-system" arg (
                              c(
                                  "routing-instance" arg (
                                      c(
                                          c(
                                            "client-list-name" arg,
                                            "clients" arg (
                                                c(
                                                    "restrict"
                                                )
                                            ).as(:oneline)
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "trap-options" (
                      c(
                          "source-address" (
                              c(
                                  c(
                                    "lo0",
                                      ipaddr
                                  )
                              )
                          ),
                          "enterprise-oid",
                          "context-oid",
                          "routing-instances" arg (
                              c(
                                  "source-address" (
                                      c(
                                          c(
                                            "lo0",
                                              ipaddr
                                          )
                                      )
                                  )
                              )
                          ),
                          "routing-instance" arg (
                              c(
                                  "source-address" (
                                      c(
                                          c(
                                            "lo0",
                                              ipaddr
                                          )
                                      )
                                  )
                              )
                          ),
                          "logical-system" arg (
                              c(
                                  "routing-instance" arg (
                                      c(
                                          "source-address" (
                                              c(
                                                  c(
                                                    "lo0",
                                                      ipaddr
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "agent-address" (
                            ("outgoing-interface")
                          )
                      )
                  ),
                  "trap-group" arg (
                      c(
                          "version" (
                            ("all" | "v1" | "v2")
                          ),
                          "destination-port" arg,
                          "categories" (
                              c(
                                  "authentication",
                                  "chassis",
                                  "link",
                                  "remote-operations",
                                  "routing",
                                  "startup",
                                  "ggsn",
                                  "rmon-alarm",
                                  "vrrp-events",
                                  "configuration",
                                  "services",
                                  "chassis-cluster",
                                  "timing-events",
                                  "dot3oam-events",
                                  "sonet-alarms" (
                                      c(
                                          "loss-of-light",
                                          "pll-lock",
                                          "loss-of-frame",
                                          "loss-of-signal",
                                          "severely-errored-frame",
                                          "line-ais",
                                          "path-ais",
                                          "loss-of-pointer",
                                          "ber-defect",
                                          "ber-fault",
                                          "line-remote-defect-indication",
                                          "path-remote-defect-indication",
                                          "remote-error-indication",
                                          "unequipped",
                                          "path-mismatch",
                                          "loss-of-cell",
                                          "vt-ais",
                                          "vt-loss-of-pointer",
                                          "vt-remote-defect-indication",
                                          "vt-unequipped",
                                          "vt-label-mismatch",
                                          "vt-loss-of-cell"
                                      )
                                  ),
                                  "otn-alarms" (
                                      c(
                                          "oc-los",
                                          "oc-lof",
                                          "oc-lom",
                                          "wavelength-lock",
                                          "otu-ais",
                                          "otu-bdi",
                                          "otu-ttim",
                                          "otu-iae",
                                          "otu-sd",
                                          "otu-sf",
                                          "otu-fec-exe",
                                          "otu-fec-deg",
                                          "otu-bbe-threshold",
                                          "otu-es-threshold",
                                          "otu-ses-threshold",
                                          "otu-uas-threshold",
                                          "odu-ais",
                                          "odu-oci",
                                          "odu-lck",
                                          "odu-bdi",
                                          "odu-ttim",
                                          "odu-sd",
                                          "odu-sf",
                                          "odu-rx-aps-change",
                                          "odu-bbe-threshold",
                                          "odu-es-threshold",
                                          "odu-ses-threshold",
                                          "odu-uas-threshold",
                                          "opu-ptm"
                                      )
                                  )
                              )
                          ),
                          "targets" arg.as(:oneline),
                          "routing-instance" arg,
                          "logical-system" arg
                      )
                  ),
                  "routing-instance-access" (
                      c(
                          "access-list" arg (
                              c(
                                  "restrict"
                              )
                          ).as(:oneline)
                      )
                  ),
                  "logical-system-trap-filter",
                  "traceoptions" (
                      c(
                          "memory-trace" (
                              c(
                                  "size" arg
                              )
                          ),
                          "no-remote-trace",
                          "file" (
                              c(
                                  "size" arg,
                                  "files" arg,
                                  "world-readable",
                                  "no-world-readable",
                                  "match" (
                                    regular_expression
                                  )
                              )
                          ).as(:oneline),
                          "flag" (("timer" | "protocol-timeouts" | "pdu" | "varbind-error" | "routing-socket" | "interface-stats" | "subagent" | "general" | "nonvolatile-sets" | "all")).as(:oneline)
                      )
                  ),
                  "rmon" (
                      c(
                          "history" arg (
                              c(
                                  "interface" (
                                    interface_name
                                  ),
                                  "bucket-size" arg,
                                  "interval" arg,
                                  "owner" arg
                              )
                          ),
                          "alarm" arg (
                              c(
                                  "description" arg,
                                  "interval" arg,
                                  "falling-threshold-interval" arg,
                                  "variable" arg,
                                  "sample-type" (
                                    ("absolute-value" | "delta-value")
                                  ),
                                  "request-type" (
                                    ("get-request" | "get-next-request" | "walk-request")
                                  ),
                                  "startup-alarm" (
                                    ("rising-alarm" | "falling-alarm" | "rising-or-falling-alarm")
                                  ),
                                  "rising-threshold" arg,
                                  "falling-threshold" arg,
                                  "rising-event-index" arg,
                                  "falling-event-index" arg,
                                  "syslog-subtag" arg
                              )
                          ),
                          "event" arg (
                              c(
                                  "description" arg,
                                  "type" (
                                    ("none" | "log" | "snmptrap" | "log-and-trap")
                                  ),
                                  "community" arg
                              )
                          )
                      )
                  ),
                  "health-monitor" (
                      c(
                          "routing-engine" (
                              c(
                                  "cpu" (
                                      c(
                                          "interval" arg,
                                          "moderate-threshold" arg,
                                          "high-threshold" arg,
                                          "critical-threshold" arg,
                                          "action" (
                                            ("monitor" | "prevent" | "recover")
                                          )
                                      )
                                  ),
                                  "memory" (
                                      c(
                                          "interval" arg,
                                          "moderate-threshold" arg,
                                          "high-threshold" arg,
                                          "critical-threshold" arg,
                                          "action" (
                                            ("monitor" | "prevent" | "recover")
                                          )
                                      )
                                  ),
                                  "storage" (
                                      c(
                                          "interval" arg,
                                          "moderate-threshold" arg,
                                          "high-threshold" arg,
                                          "critical-threshold" arg,
                                          "action" (
                                            ("monitor" | "prevent" | "recover")
                                          )
                                      )
                                  ),
                                  "temperature" (
                                      c(
                                          "interval" arg,
                                          "moderate-threshold" arg,
                                          "high-threshold" arg,
                                          "critical-threshold" arg
                                      )
                                  ),
                                  "process-count" (
                                      c(
                                          "interval" arg,
                                          "moderate-threshold" arg,
                                          "high-threshold" arg,
                                          "critical-threshold" arg,
                                          "action" (
                                            ("monitor" | "prevent" | "recover")
                                          )
                                      )
                                  ),
                                  "open-files-count" (
                                      c(
                                          "interval" arg,
                                          "moderate-threshold" arg,
                                          "high-threshold" arg,
                                          "critical-threshold" arg,
                                          "action" (
                                            ("monitor" | "prevent" | "recover")
                                          )
                                      )
                                  ),
                                  "interval" arg,
                                  "moderate-threshold" arg,
                                  "high-threshold" arg,
                                  "critical-threshold" arg,
                                  "action" (
                                    ("monitor" | "prevent" | "recover")
                                  ),
                                  "traceoptions" (
                                      c(
                                          "file" (
                                              c(
                                                    arg,
                                                  "size" arg,
                                                  "files" arg,
                                                  "world-readable",
                                                  "no-world-readable"
                                              )
                                          ).as(:oneline),
                                          "flag" (("configuration" | "memory" | "diagnostic" | "all")).as(:oneline)
                                      )
                                  )
                              )
                          ),
                          "interval" arg,
                          "rising-threshold" arg,
                          "falling-threshold" arg,
                          "idp" (
                              c(
                                  "interval" arg,
                                  "rising-threshold" arg,
                                  "falling-threshold" arg
                              )
                          )
                      )
                  ),
                  "arp" (
                      c(
                          "host-name-resolution"
                      )
                  )
              )
          ),
          "forwarding-options" (
            juniper_forwarding_options
          ),
          "event-options" (
              c(
                  "max-policies" arg,
                  "generate-event" arg (
                      c(
                          c(
                            "time-of-day" (
                              time
                            ),
                            "time-interval" arg
                          ),
                          "no-drift"
                      )
                  ).as(:oneline),
                  "policy" arg (
                      c(
                          "events" arg,
                          "within" arg (
                              c(
                                  "trigger" (
                                      c(
                                          c(
                                            "until",
                                            "on",
                                            "after"
                                          ),
                                          arg
                                      )
                                  ).as(:oneline),
                                  "events" arg,
                                  "not" (
                                      c(
                                          "events" arg
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "attributes-match" (
                              s(
                                      arg,
                                      (("equals" | "starts-with" | "matches")),
                                      arg
                              )
                          ).as(:oneline),
                          "then" (
                              c(
                                  "ignore",
                                  "priority-override" (
                                      c(
                                          "facility" (
                                            ("authorization" | "daemon" | "ftp" | "ntp" | "security" | "kernel" | "user" | "dfc" | "external" | "firewall" | "pfe" | "conflict-log" | "change-log" | "interactive-commands")
                                          ),
                                          "severity" (
                                            ("emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info")
                                          )
                                      )
                                  ),
                                  "upload" (
                                      s(
                                        "filename" arg,
                                        "destination" arg,
                                        c(
                                          "user-name" arg,
                                          "transfer-delay" arg,
                                          "retry-count" (
                                              c(
                                                    arg,
                                                  "retry-interval" arg
                                              )
                                          ).as(:oneline)
                                        )
                                      )
                                  ),
                                  "change-configuration" (
                                      c(
                                          "retry" (
                                              c(
                                                  "count" arg,
                                                  "interval" arg
                                              )
                                          ).as(:oneline),
                                          "commands" arg,
                                          "user-name" arg,
                                          "commit-options" (
                                              c(
                                                  "check" (
                                                      c(
                                                          "synchronize"
                                                      )
                                                  ),
                                                  "synchronize",
                                                  "force",
                                                  "log" arg
                                              )
                                          )
                                      )
                                  ),
                                  "execute-commands" (
                                      c(
                                          "commands" arg,
                                          "user-name" arg,
                                          "output-filename" arg,
                                          "destination" arg (
                                              c(
                                                  "transfer-delay" arg,
                                                  "retry-count" (
                                                      c(
                                                            arg,
                                                          "retry-interval" arg
                                                      )
                                                  ).as(:oneline)
                                              )
                                          ),
                                          "output-format" (
                                            ("text" | "xml")
                                          )
                                      )
                                  ),
                                  "event-script" arg (
                                      c(
                                          "arguments" arg (
                                              c(
                                                  arg
                                              )
                                          ).as(:oneline),
                                          "user-name" arg,
                                          "output-filename" arg,
                                          "destination" arg (
                                              c(
                                                  "transfer-delay" arg,
                                                  "retry-count" (
                                                      c(
                                                            arg,
                                                          "retry-interval" arg
                                                      )
                                                  ).as(:oneline)
                                              )
                                          ),
                                          "output-format" (
                                            ("text" | "xml")
                                          )
                                      )
                                  ),
                                  "raise-trap"
                              )
                          )
                      )
                  ),
                  "event-script" (
                      c(
                          "optional",
                          "max-datasize" arg,
                          "dampen" (
                              c(
                                  "dampen-options" (
                                      c(
                                          "cpu-factor" arg,
                                          "line-interval" arg,
                                          "time-interval" arg
                                      )
                                  )
                              )
                          ),
                          "traceoptions" (
                              c(
                                  "no-remote-trace",
                                  "file" (
                                      c(
                                            arg,
                                          "size" arg,
                                          "files" arg,
                                          "world-readable",
                                          "no-world-readable"
                                      )
                                  ).as(:oneline),
                                  "flag" (("events" | "input" | "offline" | "output" | "rpc" | "xslt" | "all")).as(:oneline)
                              )
                          ),
                          "file" arg (
                              c(
                                  "source" arg,
                                  "python-script-user" arg,
                                  "dampen" (
                                      c(
                                          "dampen-options" (
                                              c(
                                                  "cpu-factor" arg,
                                                  "line-interval" arg,
                                                  "time-interval" arg
                                              )
                                          )
                                      )
                                  ),
                                  "refresh",
                                  "refresh-from" arg,
                                  "checksum" (
                                      c(
                                          "md5" arg,
                                          "sha1" arg,
                                          "sha-256" arg
                                      )
                                  ),
                                  "remote-execution" arg (
                                      c(
                                          "username" arg,
                                          "passphrase" (
                                            unreadable
                                          )
                                      )
                                  )
                              )
                          ),
                          "refresh",
                          "refresh-from" arg
                      )
                  ),
                  "destinations" arg (
                      c(
                          "transfer-delay" arg,
                          "archive-sites" arg (
                              c(
                                  "password" (
                                    unreadable
                                  )
                              )
                          ).as(:oneline)
                      )
                  ),
                  "traceoptions" (
                      c(
                          "no-remote-trace",
                          "file" (
                              c(
                                    arg,
                                  "size" arg,
                                  "files" arg,
                                  "world-readable",
                                  "no-world-readable",
                                  "match" (
                                    regular_expression
                                  )
                              )
                          ).as(:oneline),
                          "flag" (("server" | "configuration" | "events" | "timer-events" | "database" | "policy" | "registration" | "syslogd" | "all")).as(:oneline)
                      )
                  ),
                  "redundancy-event" (
                    srd_events_object
                  )
              )
          ),
          "accounting-options" (
            juniper_accounting_options
          ),
          "routing-options" (
            juniper_routing_options
          ),
          "multicast-snooping-options" (
            juniper_multicast_snooping_options
          ),
          "protocols" (
            juniper_protocols
          ),
          "policy-options" (
            juniper_policy_options
          ),
          "class-of-service" (
            juniper_class_of_service_options
          ),
          "firewall" (
              c(
                  "family" (
                      c(
                          "inet" (
                              c(
                                  "dialer-filter" (
                                    inet_dialer_filter
                                  ),
                                  "prefix-action" (
                                    prefix_action
                                  ),
                                  "filter" (
                                    inet_filter
                                  ),
                                  "template" (
                                    inet_template
                                  ),
                                  "simple-filter" (
                                    inet_simple_filter
                                  ),
                                  "service-filter" (
                                    inet_service_filter
                                  ),
                                  "fast-update-filter" (
                                    inet_fuf
                                  )
                              )
                          ),
                          "inet6" (
                              c(
                                  "dialer-filter" (
                                    inet6_dialer_filter
                                  ),
                                  "filter" (
                                    inet6_filter
                                  ),
                                  "service-filter" (
                                    inet6_service_filter
                                  ),
                                  "fast-update-filter" (
                                    inet6_fuf
                                  ),
                                  "template" (
                                    inet6_template
                                  )
                              )
                          ),
                          "mpls" (
                              c(
                                  "dialer-filter" (
                                    mpls_dialer_filter
                                  ),
                                  "filter" (
                                    mpls_filter
                                  ),
                                  "template" (
                                    mpls_template
                                  )
                              )
                          ),
                          "vpls" (
                              c(
                                  "filter" (
                                    vpls_filter
                                  )
                              )
                          ),
                          "evpn" (
                              c(
                                  "filter" (
                                    vpls_filter
                                  )
                              )
                          ),
                          "bridge" (
                              c(
                                  "filter" (
                                    bridge_filter
                                  )
                              )
                          ),
                          "ccc" (
                              c(
                                  "filter" (
                                    ccc_filter
                                  )
                              )
                          ),
                          "any" (
                              c(
                                  "filter" (
                                    any_filter
                                  ),
                                  "template" (
                                    any_template
                                  )
                              )
                          ),
                          "ethernet-switching" (
                              c(
                                  "filter" (
                                    es_filter
                                  ),
                                  "template" (
                                    es_template
                                  )
                              )
                          )
                      )
                  ),
                  "policer" (
                    firewall_policer
                  ),
                  "flexible-match" (
                    firewall_flexible_match
                  ),
                  "tunnel-end-point" (
                    tunnel_end_point
                  ),
                  "hierarchical-policer" (
                    firewall_hierpolicer
                  ),
                  "interface-set" (
                    interface_set_type
                  ),
                  "load-balance-group" (
                    firewall_load_balance_group
                  ),
                  "atm-policer" (
                    atm_policer_type
                  ),
                  "three-color-policer" (
                    three_color_policer_type
                  ),
                  "filter" (
                    inet_filter
                  )
              )
          ),
          "access" (
            juniper_access_options
          ),
          "routing-instances" (
              c(
                    juniper_routing_instance
              )
          ),
          "bridge-domains" (
              c(
                    juniper_bridge_domains
              )
          ),
          "fabric" (
              c(
                  "routing-instances" (
                      c(
                            juniper_fabric_routing_instance
                      )
                  ),
                  "routing-options" (
                    juniper_fabric_routing_options
                  ),
                  "protocols" (
                      c(
                          "bgp" (
                            juniper_protocols_bgp
                          )
                      )
                  ),
                  "virtual-chassis" (
                      c(
                          "flow-groups" (
                              c(
                                    flow_group_type,
                                  "node-device" arg (
                                      c(
                                          "interconnect-device" arg (
                                              c(
                                                  "preference" (
                                                    ("high" | "normal" | "never")
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "traceoptions" (
                            juniper_virtual_chassis_traceoptions
                          )
                      )
                  )
              )
          ),
          "switch-options" (
            juniper_def_rtb_switch_options
          ),
          "unified-edge" (
              c(
                  "cos-cac" (
                    juniper_unified_edge_cos_options
                  ),
                  "local-policies" arg (
                      c(
                          "description" arg,
                          "resource-threshold-profile" arg,
                          "classifier-profile" arg,
                          "cos-policy-profile" arg,
                          "roamer-classifier-profile" arg,
                          "roamer-cos-policy-profile" arg,
                          "visitor-classifier-profile" arg,
                          "visitor-cos-policy-profile" arg,
                          "traffic-class-qci-mapping-profile" arg,
                          "ul-bandwidth-pool" arg,
                          "dl-bandwidth-pool" arg
                      )
                  ),
                  "aaa" (
                      c(
                          "traceoptions" (
                            aaa_traceoptions
                          ),
                          "profiles" (
                            aaa_profile
                          )
                      )
                  ),
                  "diameter-profiles" (
                    mobile_diameter_profiles
                  ),
                  "gateways" (
                      c(
                          "ggsn-pgw" arg (
                              c(
                                  "service-mode" (
                                    ("maintenance")
                                  ),
                                  "maximum-bearers" arg,
                                  "session-timeout-check-interval" arg,
                                  "redirect-timeout" arg,
                                  "local-policy-profile" arg,
                                  "pfes" (
                                      c(
                                          "guaranteed-bandwidth" arg,
                                          "maximum-bearers" arg,
                                          "default-bearers-percentage" arg,
                                          "ipv4-nbm-prefixes" arg,
                                          "ipv6-nbm-prefixes" arg,
                                          "maximum-sdfs" arg
                                      )
                                  ),
                                  "anchor-pfe-guaranteed-bandwidth" arg,
                                  "anchor-pfe-maximum-bearers" arg,
                                  "anchor-pfe-default-bearers-percentage" arg,
                                  "anchor-pfe-ipv4-nbm-prefixes" arg,
                                  "anchor-pfe-ipv6-nbm-prefixes" arg,
                                  "preemption" (
                                      c(
                                          "enable",
                                          "gtpv1-pvi-disable",
                                          "gtpv1-pci-disable"
                                      )
                                  ),
                                  "gtp" (
                                    mobile_gateway_config_gtp
                                  ),
                                  "home-plmn" (
                                      c(
                                          "mcc" (
                                              s(
                                                      arg,
                                                "mnc" arg
                                              )
                                          )
                                      )
                                  ),
                                  "traceoptions" (
                                    mobile_smd_traceoptions
                                  ),
                                  "call-rate-statistics" (
                                      c(
                                          "interval" arg,
                                          "history" arg
                                      )
                                  ),
                                  "service-selection-profiles" arg (
                                      c(
                                          "term" arg (
                                              c(
                                                  "from" (
                                                      c(
                                                          "imsi" arg,
                                                          "msisdn" arg,
                                                          "imei" arg,
                                                          "anonymous-user",
                                                          "domain-name" arg,
                                                          "roaming-status" (
                                                            ("home" | "roamer" | "visitor")
                                                          ),
                                                          "plmn" (
                                                              c(
                                                                  "mcc" (
                                                                      s(
                                                                              arg,
                                                                        "mnc" arg
                                                                      )
                                                                  ),
                                                                  "except"
                                                              )
                                                          ),
                                                          "charging-characteristics" arg,
                                                          "maximum-bearers" arg,
                                                          "peer" (
                                                            ipaddr
                                                          ),
                                                          "peer-routing-instance" arg,
                                                          "pdn-type" (
                                                            ("ipv4" | "ipv6" | "ipv4v6")
                                                          ),
                                                          "rat-type" (
                                                            ("geran" | "utran" | "eutran" | "wlan" | "hspa")
                                                          )
                                                      )
                                                  ),
                                                  "then" (
                                                      c(
                                                          "redirect-peer" arg.as(:oneline),
                                                          "accept",
                                                          "reject",
                                                          "apn-name" arg,
                                                          "pcef-profile" arg,
                                                          "charging-profile" arg
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "apn-services" (
                                    ggsn_pgw_apn_services
                                  ),
                                  "system" (
                                    unified_edge_ggsn_pgw_system
                                  ),
                                  "diameter" (
                                    unified_edge_gateway_diameter
                                  ),
                                  "charging" (
                                      c(
                                          "traceoptions" (
                                            charging_traceoptions
                                          ),
                                          "charging-profiles" (
                                              c(
                                                    juniper_charging_profiles
                                              )
                                          ),
                                          "transport-profiles" (
                                              c(
                                                    juniper_transport_profiles
                                              )
                                          ),
                                          "cdr-profiles" (
                                              c(
                                                    juniper_cdr_profiles
                                              )
                                          ),
                                          "trigger-profiles" (
                                              c(
                                                    juniper_trigger_profiles
                                              )
                                          ),
                                          "local-persistent-storage-options" (
                                            juniper_charged_configuraton
                                          ),
                                          "gtpp" (
                                              c(
                                                  "source-interface" (
                                                      c(
                                                            interface_name,
                                                          "ipv4-address" (
                                                            ipv4addr
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "destination-port" arg,
                                                  "n3-requests" arg,
                                                  "transport-protocol" (
                                                    ("udp" | "tcp")
                                                  ),
                                                  "version" (
                                                    ("v0" | "v1" | "v2")
                                                  ),
                                                  "echo-interval" arg,
                                                  "no-path-management",
                                                  "t3-response" arg,
                                                  "header-type" (
                                                    ("short" | "long")
                                                  ),
                                                  "pending-queue-size" arg,
                                                  "down-detect-time" arg,
                                                  "reconnect-time" arg,
                                                  "peer" (
                                                    gtpp_peer
                                                  )
                                              )
                                          ),
                                          "diameter-avp-profiles" (
                                              c(
                                                    juniper_diameter_avp_profiles
                                              )
                                          )
                                      )
                                  ),
                                  "ip-reassembly-profile" (
                                      c(
                                            arg
                                      )
                                  ),
                                  "ipv6-router-advertisement" (
                                    mobile_gateways_ipv6_router_advertisement
                                  ),
                                  "software-datapath" (
                                      c(
                                          "traceoptions" (
                                            software_datapath_traceoptions
                                          )
                                      )
                                  ),
                                  "inline-services" (
                                      c(
                                          "ip-reassembly" (
                                              c(
                                                  "service-set" (
                                                      c(
                                                            arg
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "sgw" arg (
                              c(
                                  "service-mode" (
                                    ("maintenance")
                                  ),
                                  "maximum-bearers" arg,
                                  "local-policy-profile" arg,
                                  "pfes" (
                                      c(
                                          "guaranteed-bandwidth" arg,
                                          "maximum-bearers" arg,
                                          "default-bearers-percentage" arg
                                      )
                                  ),
                                  "anchor-pfe-guaranteed-bandwidth" arg,
                                  "anchor-pfe-maximum-bearers" arg,
                                  "anchor-pfe-default-bearers-percentage" arg,
                                  "preemption" (
                                      c(
                                          "enable"
                                      )
                                  ),
                                  "remote-delete-on-peer-fail",
                                  "gtp" (
                                    sgw_config_gtp
                                  ),
                                  "home-plmn" (
                                      c(
                                          "mcc" (
                                              s(
                                                      arg,
                                                "mnc" arg
                                              )
                                          )
                                      )
                                  ),
                                  "traceoptions" (
                                    mobile_smd_traceoptions
                                  ),
                                  "call-rate-statistics" (
                                      c(
                                          "interval" arg,
                                          "history" arg
                                      )
                                  ),
                                  "system" (
                                    unified_edge_sgw_system
                                  ),
                                  "charging" (
                                      c(
                                          "traceoptions" (
                                            charging_traceoptions
                                          ),
                                          "charging-profiles" (
                                              c(
                                                    juniper_charging_profiles
                                              )
                                          ),
                                          "transport-profiles" (
                                              c(
                                                    juniper_transport_profiles
                                              )
                                          ),
                                          "cdr-profiles" (
                                              c(
                                                    juniper_cdr_profiles
                                              )
                                          ),
                                          "trigger-profiles" (
                                              c(
                                                    juniper_trigger_profiles
                                              )
                                          ),
                                          "local-persistent-storage-options" (
                                            juniper_charged_configuraton
                                          ),
                                          "gtpp" (
                                              c(
                                                  "source-interface" (
                                                      c(
                                                            interface_name,
                                                          "ipv4-address" (
                                                            ipv4addr
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "destination-port" arg,
                                                  "n3-requests" arg,
                                                  "transport-protocol" (
                                                    ("udp" | "tcp")
                                                  ),
                                                  "version" (
                                                    ("v0" | "v1" | "v2")
                                                  ),
                                                  "echo-interval" arg,
                                                  "no-path-management",
                                                  "t3-response" arg,
                                                  "header-type" (
                                                    ("short" | "long")
                                                  ),
                                                  "pending-queue-size" arg,
                                                  "down-detect-time" arg,
                                                  "reconnect-time" arg,
                                                  "peer" (
                                                    gtpp_peer
                                                  )
                                              )
                                          ),
                                          "global-profile" (
                                              c(
                                                  "default-profile" arg,
                                                  "home-profile" arg,
                                                  "roamer-profile" arg,
                                                  "visitor-profile" arg,
                                                  "profile-selection-order" (
                                                    ("static" | "serving" | "pgw-cg-addr")
                                                  )
                                              )
                                          )
                                      )
                                  ),
                                  "ip-reassembly-profile" (
                                      c(
                                            arg
                                      )
                                  ),
                                  "idle-mode-buffering" (
                                    sgw_idle_mode_buffering
                                  ),
                                  "software-datapath" (
                                      c(
                                          "traceoptions" (
                                            software_datapath_traceoptions
                                          )
                                      )
                                  ),
                                  "inline-services" (
                                      c(
                                          "ip-reassembly" (
                                              c(
                                                  "service-set" (
                                                      c(
                                                            arg
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          ),
                          "tdf" (
                            unified_edge_tdf
                          )
                      )
                  ),
                  "mobile-options" (
                    unified_edge_mobile_options
                  ),
                  "pcef" (
                    unified_edge_pcef
                  ),
                  "resource-management" (
                      c(
                          "server" (
                              c(
                                  "traceoptions" (
                                    rmpsd_traceoptions_type
                                  )
                              )
                          ),
                          "client" (
                              c(
                                  "traceoptions" (
                                    rmps_clnt_traceoptions_type
                                  )
                              )
                          )
                      )
                  )
              )
          ),
          "jsrc" (
            jsrc_options
          ),
          "vmhost" (
              c(
                  "no-auto-recovery",
                  "management-if" (
                      c(
                          "link-mode" (
                            ("automatic" | "half-duplex" | "full-duplex")
                          ),
                          "speed" (
                            ("automatic" | "10m" | "100m" | "1g")
                          ),
                          "disable"
                      )
                  )
              )
          ),
          "applications" (
              c(
                  "application" (
                    application_object
                  ),
                  "application-set" (
                    application_set_object
                  )
              )
          ),
          "diameter" (
              c(
                  "origin" (
                      c(
                          "realm" arg,
                          "host" arg
                      )
                  ),
                  "network-element" arg (
                      c(
                          "dne-origin" (
                              c(
                                  "realm" arg,
                                  "host" arg
                              )
                          ),
                          "function" (
                            ("jsrc" | "packet-triggered-subscribers" | "gx-plus" | "sd-3gpp" | "nasreq" | "pcrf" | "ocs")
                          ),
                          "peer" arg (
                              c(
                                  "priority" arg
                              )
                          ),
                          "forwarding" (
                              c(
                                  "route" arg (
                                      c(
                                          "function" (
                                              c(
                                                  c(
                                                    "jsrc",
                                                    "packet-triggered-subscribers",
                                                    "gx-plus",
                                                    "sd-3gpp",
                                                    "nasreq",
                                                    "pcrf",
                                                    "ocs"
                                                  ),
                                                  "partition" arg
                                              )
                                          ).as(:oneline),
                                          "destination" (
                                              c(
                                                  "realm" arg,
                                                  "host" arg
                                              )
                                          ).as(:oneline),
                                          "metric" arg
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "transport" arg (
                      c(
                          "address" (
                            ipaddr
                          ),
                          c(
                            "logical-system" (
                                c(
                                    arg,
                                    "routing-instance" arg
                                )
                            ).as(:oneline),
                            "routing-instance" arg
                          )
                      )
                  ),
                  "peer" arg (
                      c(
                          "address" (
                            ipaddr
                          ),
                          "send-origin-state-id",
                          c(
                            "logical-system" (
                                c(
                                    arg,
                                    "routing-instance" arg
                                )
                            ).as(:oneline),
                            "routing-instance" arg
                          ),
                          "connect-actively" (
                              c(
                                  "transport" arg,
                                  "port" arg
                              )
                          ),
                          "peer-origin" (
                              c(
                                  "realm" arg,
                                  "host" arg
                              )
                          )
                      )
                  )
              )
          ),
          "poe" (
              c(
                  "management" (
                    ("static" | "class" | "high-power")
                  ),
                  "guard-band" arg,
                  "notification-control" (
                      c(
                          "fpc" arg (
                              c(
                                  "disable"
                              )
                          )
                      )
                  ),
                  "lldp-priority",
                  "interface" ("all" | "all-extended" | arg) (
                      c(
                          "disable",
                          "priority" (
                            ("low" | "high")
                          ),
                          "maximum-power" arg,
                          "telemetries" (
                              c(
                                  "disable",
                                  "interval" arg,
                                  "duration" arg
                              )
                          ),
                          "fourpair-poe",
                          "ultrahigh-poe"
                      )
                  )
              )
          ),
          "session-limit-group" arg (
              c(
                  "maximum-sessions" arg
              )
          ).as(:oneline),
          "virtual-chassis" (
              c(
                  "auto-sw-update" (
                      c(
                          "package-name" arg,
                          "ex-4200" (
                              c(
                                  "package-name" arg
                              )
                          ),
                          "ex-4500" (
                              c(
                                  "package-name" arg
                              )
                          ),
                          "ex-4300" (
                              c(
                                  "package-name" arg
                              )
                          ),
                          "ex-4600" (
                              c(
                                  "package-name" arg
                              )
                          ),
                          "qfx-3" (
                              c(
                                  "package-name" arg
                              )
                          ),
                          "qfx-5" (
                              c(
                                  "package-name" arg
                              )
                          )
                      )
                  ),
                  c(
                    "preprovisioned",
                    "auto-provisioned"
                  ),
                  "id" (
                    isosysid
                  ),
                  "graceful-restart" (
                      c(
                            ("disable")
                      )
                  ),
                  "no-split-detection",
                  "traceoptions" (
                    juniper_virtual_chassis_traceoptions
                  ),
                  "heartbeat-timeout" arg,
                  "heartbeat-address" (
                    ipaddr
                  ),
                  "heartbeat-tos" arg,
                  "locality-bias",
                  "member" arg (
                      c(
                          "mastership-priority" arg,
                          "fabric-tree-root",
                          "role" (
                            ("routing-engine" | "line-card")
                          ),
                          "serial-number" arg,
                          "no-management-vlan",
                          "location" arg
                      )
                  ),
                  "aliases" (
                      c(
                          "serial-number" arg (
                              c(
                                  "alias-name" arg
                              )
                          )
                      )
                  ),
                  "mac-persistence-timer" (
                      c(
                            arg,
                          "disable"
                      )
                  ),
                  "fast-failover" (
                      c(
                          "ge",
                          "xe",
                          "et",
                          "vcp" (
                              c(
                                  "disable"
                              )
                          )
                      )
                  ),
                  "vc-port" (
                      c(
                          "lag-hash" (
                            ("packet-based" | "source-port-based")
                          )
                      )
                  ),
                  "vcp-no-hold-time"
              )
          ),
          "ethernet-switching-options" (
            juniper_ethernet_options
          ),
          "vlans" (
              c(
                    vlan_types
              )
          )
      )
end

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

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

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

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

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

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

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

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

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

rule(:application_object) do
  arg.as(:arg) (
    c(
        "application-protocol" (
          ("bootp" | "dce-rpc" | "dce-rpc-portmap" | "dns" | "exec" | "ftp" | "gprs-gtp-c" | "gprs-gtp-u" | "gprs-gtp-v0" | "gprs-sctp" | "h323" | "icmp" | "icmpv6" | "ignore" | "iiop" | "ike-esp-nat" | "ip" | "login" | "mgcp-ca" | "mgcp-ua" | "ms-rpc" | "netbios" | "netshow" | "none" | "pptp" | "q931" | "ras" | "realaudio" | "rpc" | "rpc-portmap" | "rsh" | "rtsp" | "sccp" | "sip" | "shell" | "snmp" | "sqlnet" | "sqlnet-v2" | "sun-rpc" | "talk" | "tftp" | "traceroute" | "http" | "winframe" | "https" | "imap" | "smtp" | "ssh" | "telnet")
        ),
        "protocol" (
          ("icmp" | "igmp" | "ipip" | "tcp" | "egp" | "udp" | "rsvp" | "gre" | "esp" | "ah" | "icmp6" | "ospf" | "pim" | "sctp" | arg)
        ),
        "source-port" (
          ("ftp-data" | "ftp" | "ssh" | "telnet" | "smtp" | "tacacs" | "tacacs-ds" | "domain" | "dhcp" | "bootps" | "bootpc" | "tftp" | "finger" | "http" | "kerberos-sec" | "pop3" | "sunrpc" | "ident" | "nntp" | "ntp" | "netbios-ns" | "netbios-dgm" | "netbios-ssn" | "imap" | "snmp" | "snmptrap" | "xdmcp" | "bgp" | "ldap" | "mobileip-agent" | "mobilip-mn" | "msdp" | "https" | "snpp" | "biff" | "exec" | "login" | "who" | "cmd" | "syslog" | "printer" | "talk" | "ntalk" | "rip" | "timed" | "klogin" | "kshell" | "ldp" | "krb-prop" | "krbupdate" | "kpasswd" | "socks" | "afs" | "pptp" | "radius" | "radacct" | "zephyr-srv" | "zephyr-clt" | "zephyr-hm" | "nfsd" | "eklogin" | "ekshell" | "rkinit" | "cvspserver" | arg)
        ),
        "destination-port" (
          ("ftp-data" | "ftp" | "ssh" | "telnet" | "smtp" | "tacacs" | "tacacs-ds" | "domain" | "dhcp" | "bootps" | "bootpc" | "tftp" | "finger" | "http" | "kerberos-sec" | "pop3" | "sunrpc" | "ident" | "nntp" | "ntp" | "netbios-ns" | "netbios-dgm" | "netbios-ssn" | "imap" | "snmp" | "snmptrap" | "xdmcp" | "bgp" | "ldap" | "mobileip-agent" | "mobilip-mn" | "msdp" | "https" | "snpp" | "biff" | "exec" | "login" | "who" | "cmd" | "syslog" | "printer" | "talk" | "ntalk" | "rip" | "timed" | "klogin" | "kshell" | "ldp" | "krb-prop" | "krbupdate" | "kpasswd" | "socks" | "afs" | "pptp" | "radius" | "radacct" | "zephyr-srv" | "zephyr-clt" | "zephyr-hm" | "nfsd" | "eklogin" | "ekshell" | "rkinit" | "cvspserver" | arg)
        ),
        "ether-type" arg,
        "snmp-command" (
          ("get" | "get-next" | "get-response" | "set" | "trap")
        ),
        "icmp-type" (
          ("echo-request" | "echo-reply" | "unreachable" | "source-quench" | "redirect" | "router-advertisement" | "router-solicit" | "time-exceeded" | "parameter-problem" | "timestamp" | "timestamp-reply" | "info-request" | "info-reply" | "mask-request" | "mask-reply" | arg)
        ),
        "icmp6-type" (
          ("echo-request" | "echo-reply" | "destination-unreachable" | "router-advertisement" | "router-solicit" | "time-exceeded" | "parameter-problem" | "packet-too-big" | "membership-query" | "membership-report" | "membership-termination" | "redirect" | "neighbor-solicit" | "neighbor-advertisement" | "router-renumbering" | "node-information-request" | "node-information-reply" | arg)
        ),
        "icmp-code" (
          ("network-unreachable" | "host-unreachable" | "protocol-unreachable" | "port-unreachable" | "fragmentation-needed" | "source-route-failed" | "destination-network-unknown" | "destination-host-unknown" | "source-host-isolated" | "destination-network-prohibited" | "destination-host-prohibited" | "network-unreachable-for-tos" | "host-unreachable-for-tos" | "communication-prohibited-by-filtering" | "host-precedence-violation" | "precedence-cutoff-in-effect" | "redirect-for-network" | "redirect-for-host" | "redirect-for-tos-and-net" | "redirect-for-tos-and-host" | "ttl-eq-zero-during-transit" | "ttl-eq-zero-during-reassembly" | "ip-header-bad" | "required-option-missing" | arg)
        ),
        "icmp6-code" (
          ("no-route-to-destination" | "administratively-prohibited" | "address-unreachable" | "port-unreachable" | "ttl-eq-zero-during-transit" | "ttl-eq-zero-during-reassembly" | "ip6-header-bad" | "unrecognized-next-header" | "unrecognized-option" | arg)
        ),
        "ttl-threshold" arg,
        "rpc-program-number" arg,
        "uuid" arg,
        "inactivity-timeout" (
          ("never" | arg)
        ),
        "gate-timeout" arg,
        "child-inactivity-timeout" arg,
        "learn-sip-register",
        "sip-call-hold-timeout" arg,
        c(
          "do-not-translate-AAAA-query-to-A-query",
          "do-not-translate-A-query-to-AAAA-query"
        )
    )
  )
end

rule(:application_set_object) do
  arg.as(:arg) (
    c(
        "description" arg,
        "application" arg,
        "application-set" arg
    )
  )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:chassis_fpc_error_type) do
    c(
        "fatal" (
          chassis_fpc_error_level_type
        ),
        "major" (
          chassis_fpc_error_level_type
        ),
        "minor" (
          chassis_fpc_error_level_type
        )
    )
end

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

rule(:chassis_fpc_type) do
  arg.as(:arg) (
    c(
        "auto-speed-detection" (
            c(
                c(
                  "disable"
                )
            )
        ),
        "sanity-poll" (
            c(
                "retry-count" arg,
                "on-error" (
                    c(
                        "raise-alarm",
                        "power" (
                          ("cycle" | "off")
                        ),
                        "write-coredump"
                    )
                )
            )
        ),
        "forwarding-options" (
            c(
                c(
                  "l2-profile-one" (
                      c(
                          "num-65-127-prefix" arg
                      )
                  ),
                  "l2-profile-two" (
                      c(
                          "num-65-127-prefix" arg
                      )
                  ),
                  "l2-profile-three" (
                      c(
                          "num-65-127-prefix" arg
                      )
                  ),
                  "l3-profile" (
                      c(
                          "num-65-127-prefix" arg
                      )
                  ),
                  "lpm-profile" (
                      c(
                          "prefix-65-127-disable",
                          "unicast-in-lpm"
                      )
                  ),
                  "exact-match-profile" (
                      c(
                          "num-65-127-prefix" arg
                      )
                  ),
                  "custom-profile" (
                      c(
                          "l2-entries" (
                              c(
                                  "num-banks" arg
                              )
                          ),
                          "l3-entries" (
                              c(
                                  "num-banks" arg
                              )
                          ),
                          "exact-match-entries" (
                              c(
                                  "num-banks" arg
                              )
                          ),
                          "lpm-entries" (
                              c(
                                  "num-banks" (
                                    ("0" | "2" | "4")
                                  ),
                                  "prefix-65-127-disable"
                              )
                          ),
                          "num-65-127-prefix" arg
                      )
                  )
                )
            )
        ),
        "pic" (
          chassis_pic_type
        ),
        "optical-options" (
            c(
                "disable-edfa",
                "no-disable-edfa",
                "disable-osc",
                "no-disable-osc",
                "wavelength" ("1568.77" | "1568.36" | "1568.26" | "1568.16" | "1568.05" | "1567.95" | "1567.85" | "1567.75" | "1567.64" | "1567.54" | "1567.44" | "1567.34" | "1567.23" | "1567.13" | "1567.03" | "1566.93" | "1566.83" | "1566.72" | "1566.62" | "1566.52" | "1566.42" | "1566.31" | "1566.21" | "1566.11" | "1566.01" | "1565.90" | "1565.80" | "1565.70" | "1565.60" | "1565.50" | "1565.39" | "1565.29" | "1565.19" | "1565.09" | "1564.99" | "1564.88" | "1564.78" | "1564.68" | "1564.58" | "1564.47" | "1564.37" | "1564.27" | "1564.17" | "1564.07" | "1563.96" | "1563.86" | "1563.76" | "1563.66" | "1563.56" | "1563.45" | "1563.35" | "1563.25" | "1563.15" | "1563.05" | "1562.95" | "1562.84" | "1562.74" | "1562.64" | "1562.54" | "1562.44" | "1562.33" | "1562.23" | "1562.13" | "1562.03" | "1561.93" | "1561.83" | "1561.72" | "1561.62" | "1561.52" | "1561.42" | "1561.32" | "1561.22" | "1561.11" | "1561.01" | "1560.91" | "1560.81" | "1560.71" | "1560.61" | "1560.50" | "1560.40" | "1560.30" | "1560.20" | "1560.10" | "1560.00" | "1559.90" | "1559.79" | "1559.69" | "1559.59" | "1559.49" | "1559.39" | "1559.29" | "1559.19" | "1559.08" | "1558.98" | "1558.88" | "1558.78" | "1558.68" | "1558.58" | "1558.48" | "1558.38" | "1558.27" | "1558.17" | "1558.07" | "1557.97" | "1557.87" | "1557.77" | "1557.67" | "1557.57" | "1557.46" | "1557.36" | "1557.26" | "1557.16" | "1557.06" | "1556.96" | "1556.86" | "1556.76" | "1556.66" | "1556.55" | "1556.45" | "1556.35" | "1556.25" | "1556.15" | "1556.05" | "1555.95" | "1555.85" | "1555.75" | "1555.65" | "1555.55" | "1555.44" | "1555.34" | "1555.24" | "1555.14" | "1555.04" | "1554.94" | "1554.84" | "1554.74" | "1554.64" | "1554.54" | "1554.44" | "1554.34" | "1554.23" | "1554.13" | "1554.03" | "1553.93" | "1553.83" | "1553.73" | "1553.63" | "1553.53" | "1553.43" | "1553.33" | "1553.23" | "1553.13" | "1553.03" | "1552.93" | "1552.83" | "1552.73" | "1552.62" | "1552.52" | "1552.42" | "1552.32" | "1552.22" | "1552.12" | "1552.02" | "1551.92" | "1551.82" | "1551.72" | "1551.62" | "1551.52" | "1551.42" | "1551.32" | "1551.22" | "1551.12" | "1551.02" | "1550.92" | "1550.82" | "1550.72" | "1550.62" | "1550.52" | "1550.42" | "1550.32" | "1550.22" | "1550.12" | "1550.02" | "1549.92" | "1549.82" | "1549.72" | "1549.62" | "1549.52" | "1549.42" | "1549.32" | "1549.21" | "1549.11" | "1549.01" | "1548.91" | "1548.81" | "1548.71" | "1548.61" | "1548.51" | "1548.41" | "1548.31" | "1548.21" | "1548.11" | "1548.02" | "1547.92" | "1547.82" | "1547.72" | "1547.62" | "1547.52" | "1547.42" | "1547.32" | "1547.22" | "1547.12" | "1547.02" | "1546.92" | "1546.82" | "1546.72" | "1546.62" | "1546.52" | "1546.42" | "1546.32" | "1546.22" | "1546.12" | "1546.02" | "1545.92" | "1545.82" | "1545.72" | "1545.62" | "1545.52" | "1545.42" | "1545.32" | "1545.22" | "1545.12" | "1545.02" | "1544.92" | "1544.82" | "1544.72" | "1544.63" | "1544.53" | "1544.43" | "1544.33" | "1544.23" | "1544.13" | "1544.03" | "1543.93" | "1543.83" | "1543.73" | "1543.63" | "1543.53" | "1543.43" | "1543.33" | "1543.23" | "1543.13" | "1543.04" | "1542.94" | "1542.84" | "1542.74" | "1542.64" | "1542.54" | "1542.44" | "1542.34" | "1542.24" | "1542.14" | "1542.04" | "1541.94" | "1541.84" | "1541.75" | "1541.65" | "1541.55" | "1541.45" | "1541.35" | "1541.25" | "1541.15" | "1541.05" | "1540.95" | "1540.85" | "1540.76" | "1540.66" | "1540.56" | "1540.46" | "1540.36" | "1540.26" | "1540.16" | "1540.06" | "1539.96" | "1539.86" | "1539.77" | "1539.67" | "1539.57" | "1539.47" | "1539.37" | "1539.27" | "1539.17" | "1539.07" | "1538.98" | "1538.88" | "1538.78" | "1538.68" | "1538.58" | "1538.48" | "1538.38" | "1538.28" | "1538.19" | "1538.09" | "1537.99" | "1537.89" | "1537.79" | "1537.69" | "1537.59" | "1537.50" | "1537.40" | "1537.30" | "1537.20" | "1537.10" | "1537.00" | "1536.90" | "1536.81" | "1536.71" | "1536.61" | "1536.51" | "1536.41" | "1536.31" | "1536.22" | "1536.12" | "1536.02" | "1535.92" | "1535.82" | "1535.72" | "1535.63" | "1535.53" | "1535.43" | "1535.33" | "1535.23" | "1535.13" | "1535.04" | "1534.94" | "1534.84" | "1534.74" | "1534.64" | "1534.54" | "1534.45" | "1534.35" | "1534.25" | "1534.15" | "1534.05" | "1533.96" | "1533.86" | "1533.76" | "1533.66" | "1533.56" | "1533.47" | "1533.37" | "1533.27" | "1533.17" | "1533.07" | "1532.98" | "1532.88" | "1532.78" | "1532.68" | "1532.58" | "1532.49" | "1532.39" | "1532.29" | "1532.19" | "1532.09" | "1532.00" | "1531.90" | "1531.80" | "1531.70" | "1531.60" | "1531.51" | "1531.41" | "1531.31" | "1531.21" | "1531.12" | "1531.02" | "1530.92" | "1530.82" | "1530.72" | "1530.63" | "1530.53" | "1530.43" | "1530.33" | "1530.24" | "1530.14" | "1530.04" | "1529.94" | "1529.85" | "1529.75" | "1529.65" | "1529.55" | "1529.46" | "1529.36" | "1529.26" | "1529.16" | "1529.07" | "1528.97" | "1528.87" | "1528.77" | "1528.38") (
                    c(
                        c(
                          "switch" (
                              c(
                                  arg
                              )
                          ),
                          "wss-express-in"
                        )
                    )
                ),
                "tca" (
                    c(
                        "osc-tx-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "osc-tx-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "osc-rx-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "osc-rx-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "osc-fiber-loss-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "osc-fiber-loss-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "lout-voa-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "lout-voa-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-in-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-in-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-out-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-out-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-sig-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-sig-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-awg-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-awg-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-express-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa1-express-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-in-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-in-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-out-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-out-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-sig-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-sig-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-awg-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-awg-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-express-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "edfa2-express-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "ocm-power-high-line-out-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "ocm-power-low-line-out-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        )
                    )
                ),
                "expansion-card" (
                    c(
                        "fpc" (
                            c(
                                  arg
                            )
                        )
                    )
                ),
                "express-in" (
                    c(
                        "fpc" (
                            c(
                                  arg
                            )
                        )
                    )
                ),
                "amplifier-chain" (
                    c(
                        "anchor-iplc",
                        "no-anchor-iplc",
                        "osc-ip" arg,
                        "osc-mac" arg,
                        "ila" arg (
                            c(
                                "ila-options" (
                                    c(
                                        "ila-ipv4-address" arg,
                                        "ila-user" arg,
                                        "ila-password" (
                                          unreadable
                                        ),
                                        "edfa-a-b" (
                                            c(
                                                "tca-input-power-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-input-power-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-output-power-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-output-power-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-signal-output-power-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-signal-output-power-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump0-current-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump0-current-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump1-current-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump1-current-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump0-temperature-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump0-temperature-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump1-temperature-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump1-temperature-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "voa-a" (
                                            c(
                                                "tca-attenuation-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-attenuation-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "osc-a" (
                                            c(
                                                "osc-tx-power-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-tx-power-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-rx-power-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-rx-power-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-fiber-loss-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-fiber-loss-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "edfa-b-a" (
                                            c(
                                                "tca-input-power-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-input-power-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-output-power-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-output-power-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-signal-output-power-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-signal-output-power-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump0-current-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump0-current-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump1-current-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump1-current-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump0-temperature-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump0-temperature-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump1-temperature-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-pump1-temperature-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "voa-b" (
                                            c(
                                                "tca-attenuation-low" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tca-attenuation-high" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "osc-b" (
                                            c(
                                                "osc-tx-power-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-tx-power-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-rx-power-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-rx-power-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-fiber-loss-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "osc-fiber-loss-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ),
        "power" (
          ("off" | "on")
        ),
        "traffic-manager" (
            c(
                "queue-threshold" (
                    c(
                        "fabric-queue" (
                            c(
                                "priority" (("low" | "high")) (
                                    c(
                                        "threshold" arg
                                    )
                                )
                            )
                        ),
                        "wan-queue" (
                            c(
                                "priority" (("low" | "medium-low" | "medium-high" | "high")) (
                                    c(
                                        "threshold" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "enhanced-priority-mode",
                "packet-timestamp" (
                  ("enable" | "disable")
                )
            )
        ),
        "route-localization" (
          ("fib-remote" | "fib-local")
        ),
        "vpn-localization" (
          ("vpn-core-facing-only" | "vpn-core-facing-default")
        ),
        "power-budget-priority" arg,
        c(
          "disable-power",
          "allow-sram-parity-errors"
        ),
        c(
          "performance-mode" (
              c(
                  "number-of-ucode-workers" arg
              )
          ),
          "lite-mode"
        ),
        "services-offload",
        "np-cache",
        "offline",
        "offline-on-fabric-bandwidth-reduction",
        "ir-mode" (
          ("IR" | "R")
        ),
        "license-mode" (
          ("r" | "ir")
        ),
        "fabric" (
            c(
                "blackhole-action" (
                  ("log-only" | "offline" | "restart" | "restart-then-offline")
                ),
                "bandwidth-degradation" (
                    c(
                        "percentage" arg,
                        "no-fabric-switchover",
                        "action" (
                          ("log-only" | "offline" | "restart" | "restart-then-offline")
                        )
                    )
                )
            )
        ),
        "port-mirror-instance" arg,
        "sampling-instance" arg,
        "inline-services" (
            c(
                "report-zero-oif-gw-on-discard",
                "flex-flow-sizing",
                "use-extended-flow-memory",
                "flow-table-size" (
                    c(
                        "ipv4-flow-table-size" arg,
                        "ipv6-flow-table-size" arg,
                        "vpls-flow-table-size" arg,
                        "ipv6-extended-attrib",
                        "mpls-flow-table-size" arg
                    )
                )
            )
        ),
        "inline-video-monitoring" (
            c(
                "maximum-flows-count" arg,
                "flow-table-size" arg
            )
        ),
        "application-services" (
            c(
                "package" arg
            )
        ),
        "slamon-services" (
            c(
                "rfc2544"
            )
        ),
        "flexible-queuing-mode",
        "loopback-device-count" arg,
        "interasic-linkerror-recovery-enable",
        "number-of-ports" (
          ("8" | "12")
        ),
        "pfe" (
          chassis_pfe_type
        ),
        "service-package" (
          ("bundle-rfc2544" | "bundle-nat-ipsec")
        ),
        "max-queues" (
          ("8k" | "16k" | "32k" | "64k" | "128k" | "256k" | "512k" | "1M")
        ),
        "bandwidth" (
          ("1.6T")
        ),
        "error" (
          chassis_fpc_error_type
        )
    )
  )
end

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

rule(:chassis_pfe_type) do
  arg.as(:arg) (
    c(
        "forwarding-packages" (
            c(
                "mobility" (
                    c(
                        c(
                          "ggsn-pgw",
                          "sgw"
                        )
                    )
                )
            )
        ),
        "tunnel-services"
    )
  )
end

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

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

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

rule(:chassis_pic_port_framing) do
  arg.as(:arg) (
    c(
        "short-reach-mode" (
          ("disable" | "enable")
        ),
        "framing" (
          ("sonet" | "sdh" | "t3" | "e3" | "t1" | "e1")
        ),
        "speed" (
          ("oc3-stm1" | "oc12-stm4" | "oc48-stm16" | "1G" | "10g" | "40g" | "100g")
        ),
        "channel-speed" (
          ("10g" | "25g" | "50g" | "disable-auto-speed-detection")
        ),
        "forwarding-mode" (
            c(
                "sa-multicast"
            )
        ),
        "no-mcast-replication"
    )
  )
end

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

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

rule(:chassis_non_stop_forwarding_type) do
    c(
        "traceoptions" (
            c(
                "flag" (("update" | "all")).as(:oneline)
            )
        )
    )
end

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

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

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

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

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

rule(:chassis_routing_engine_type) do
    c(
        "on-disk-failure" (
          chassis_re_on_disk_failure
        ),
        "control-interface" (
            c(
                "recovery-method" (
                  ("disable-recovery" | "socket" | "counter")
                ),
                "pause-frame"
            )
        ),
        "bios" (
            c(
                "no-auto-upgrade",
                "uninterrupt"
            )
        ),
        "usb-wwan" (
            c(
                "port" (
                  ("0" | "1")
                )
            )
        )
    )
end

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

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

rule(:chassis_sib_type) do
    c(
        "minimum" arg,
        "power-off" (
            c(
                "slot" arg
            )
        )
    )
end

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

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

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

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

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

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

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

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

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

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

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

rule(:cos_policer_input_priority_map) do
    c(
        "ieee-802.1p" (
            c(
                "premium" arg
            )
        )
    )
end

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

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

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

rule(:cpcd_action_object_type) do
    c(
        c(
          "accept",
          "rewrite" (
              c(
                  "destination-address" (
                    ipaddr
                  ),
                  "destination-port" arg
              )
          ),
          "redirect" (
              c(
                  arg
              )
          ).as(:oneline)
        ),
        "syslog"
    )
end

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

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

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

rule(:ct3_channel_type) do
  arg.as(:arg) (
    c(
        "channel-group" arg (
            c(
                "timeslots" arg
            )
        ).as(:oneline)
    )
  )
end

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

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

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

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

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

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

rule(:demux_options_type) do
    c(
        "underlying-interface" (
          ("$junos-underlying-interface" | "$junos-interface-ifd-name" | arg)
        )
    )
end

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

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

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

rule(:dfc_notification_target_type) do
  arg.as(:arg) (
    c(
        "port" arg
    )
  ).as(:oneline)
end

rule(:dhcp_client_type) do
    c(
        "client-identifier" (
            c(
                c(
                  "ascii" arg,
                  "hexadecimal" arg
                ),
                "user-id" (
                    c(
                        c(
                          "ascii" arg,
                          "hexadecimal" arg
                        )
                    )
                ).as(:oneline),
                "prefix" (
                    c(
                        "host-name",
                        "logical-system-name",
                        "routing-instance-name"
                    )
                ),
                "use-interface-description" (
                  ("logical" | "device")
                )
            )
        ),
        "no-dns-install",
        "lease-time" (
          ("infinite" | arg)
        ),
        "retransmission-attempt" arg,
        "retransmission-interval" arg,
        "server-address" (
          ipv4addr
        ),
        "update-server",
        "vendor-id" arg,
        "options" (
            c(
                "no-hostname"
            )
        )
    )
end

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

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

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

rule(:dynamic_attack_group_type) do
  arg.as(:arg) (
    c(
        "attack-group-description" arg,
        "filters" (
            c(
                "direction" (
                    c(
                        "expression" (
                          ("and" | "or")
                        ),
                        "values" (
                          ("client-to-server" | "server-to-client" | "any" | "exclude-client-to-server" | "exclude-server-to-client" | "exclude-any")
                        )
                    )
                ),
                "severity" (
                    c(
                        "values" (
                          ("info" | "warning" | "minor" | "major" | "critical")
                        )
                    )
                ),
                "type" (
                    c(
                        "values" (
                          ("signature" | "anomaly")
                        )
                    )
                ),
                "recommended",
                "no-recommended",
                "performance" (
                    c(
                        "values" (
                          ("unknown" | "fast" | "normal" | "slow")
                        )
                    )
                ),
                "category" (
                    c(
                        "values" arg
                    )
                ),
                "service" (
                    c(
                        "values" arg
                    )
                ),
                "false-positives" (
                    c(
                        "values" (
                          ("unknown" | "rarely" | "occasionally" | "frequently")
                        )
                    )
                ),
                "products" (
                    c(
                        "values" arg
                    )
                )
            )
        )
    )
  )
end

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

rule(:epd_threshold_config) do
    c(
        arg,
        "plp1" arg
    ).as(:oneline)
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:ggsn_pgw_apn_services) do
    c(
        "apns" (
            c(
                  ggsn_pgw_apn
            )
        )
    )
end

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

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

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

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

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

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

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

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

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

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

rule(:header_manipulation_modify_type) do
  arg.as(:arg) (
    c(
        "with" arg
    )
  ).as(:oneline)
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:firewall_addr6_simple_object) do
    c(
          ipv6prefix
    )
end

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

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

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

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

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

rule(:firewall_addr_simple_object) do
    c(
          ipv4prefix
    )
end

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

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

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

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

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

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

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

rule(:interfaces_type) do
  ("$junos-interface-ifd-name" | arg).as(:arg) (
    c(
        "description" arg,
        "metadata" arg,
          ("disable"),
        "promiscuous-mode",
        "port-mirror-instance" arg,
        "multicast-statistics",
        "oam-on-svlan",
        "fabric-options" (
            c(
                "member-interfaces" arg
            )
        ),
        "traceoptions" (
            c(
                "flag" (("ipc" | "event" | "media" | "all")).as(:oneline)
            )
        ),
        "passive-monitor-mode",
        c(
          "keepalives" (
            keepalives_type
          ).as(:oneline),
          "no-keepalives"
        ),
        "traps",
        "no-traps",
        "interface-mib",
        "no-interface-mib",
        "accounting-profile" arg,
        "anchor-point" (
            c(
                  interface_device
            )
        ),
        "bypass-queueing-chip",
        "no-bypass-queueing-chip",
        c(
          "per-unit-scheduler",
          "no-per-unit-scheduler",
          "shared-scheduler",
          "hierarchical-scheduler" (
              c(
                  "maximum-hierarchy-levels" arg,
                  "implicit-hierarchy"
              )
          ).as(:oneline)
        ),
        "l2tp-maximum-session" arg,
        "schedulers" arg,
        "interface-transmit-statistics",
        "cascade-port",
        "dce",
        c(
          "vlan-tagging",
          "stacked-vlan-tagging",
          "flexible-vlan-tagging",
          "vlan-vci-tagging"
        ),
        "native-vlan-id" arg,
        "no-native-vlan-insert",
        "speed" (
          ("auto" | "auto-10m-100m" | "10m" | "100m" | "1g" | "10g" | "40g" | "oc3" | "oc12" | "oc48")
        ),
        "forwarding-class-accounting" (
            c(
                "direction" (
                  ("ingress" | "egress" | "both")
                ),
                "enhanced" (
                    c(
                        "traffic-type" (
                          ("unicast-statistics" | "multicast-statistics")
                        ),
                        "family" (
                          ("inet" | "inet6" | "both")
                        ),
                        "direction" (
                          ("ingress" | "egress" | "both")
                        ),
                        "overhead-bytes" arg
                    )
                )
            )
        ),
        "auto-configure" (
          auto_configure_vlan_type
        ),
        "mtu" arg,
        "hold-time" (
            c(
                "up" arg,
                "down" arg
            )
        ).as(:oneline),
        "damping" (
            c(
                "half-life" arg,
                "max-suppress" arg,
                "reuse" arg,
                "suppress" arg,
                "enable"
            )
        ),
        "link-degrade-monitor" (
            c(
                "actions" (
                    c(
                        c(
                          "media-based"
                        )
                    )
                ),
                "recovery" (
                    c(
                        "timer" arg,
                        c(
                          "auto",
                          "manual"
                        )
                    )
                ),
                "thresholds" (
                    c(
                        "set" arg,
                        "clear" arg,
                        "warning-set" arg,
                        "warning-clear" arg,
                        "interval" arg
                    )
                )
            )
        ),
        "satop-options" (
            c(
                "idle-pattern" arg,
                "payload-size" arg,
                "excessive-packet-loss-rate" (
                    c(
                        "threshold" arg,
                        "sample-period" arg
                    )
                ),
                c(
                  "jitter-buffer-packets" arg,
                  "jitter-buffer-latency" arg,
                  "jitter-buffer-auto-adjust"
                ),
                "bit-rate" arg
            )
        ),
        "cesopsn-options" (
            c(
                "idle-pattern" arg,
                "packetization-latency" arg,
                "payload-size" arg,
                "excessive-packet-loss-rate" (
                    c(
                        "threshold" arg,
                        "sample-period" arg
                    )
                ),
                c(
                  "jitter-buffer-packets" arg,
                  "jitter-buffer-latency" arg,
                  "jitter-buffer-auto-adjust"
                ),
                "bit-rate" arg
            )
        ),
        "ima-group-options" (
            c(
                "frame-length" (
                  ("32" | "64" | "128" | "256")
                ),
                "symmetry" (
                  ("symmetrical-config-and-operation" | "symmetrical-config-asymmetrical-operation")
                ),
                "transmit-clock" (
                  ("common" | "independent")
                ),
                "version" (
                  ("1.0" | "1.1")
                ),
                "minimum-links" (
                    c(
                        c(
                            arg
                        )
                    )
                ),
                "frame-synchronization" (
                    c(
                        "alpha" arg,
                        "beta" arg,
                        "gamma" arg
                    )
                ),
                "test-procedure" (
                    c(
                        "period" arg,
                        "interface" (
                          interface_device
                        ),
                        "pattern" arg
                    )
                ),
                "differential-delay" arg
            )
        ),
        "ima-link-options" (
            c(
                "group-id" arg
            )
        ),
        "multi-chassis-protection" (
          multi_chassis_protection_group
        ),
        "clocking" (
            c(
                c(
                  "internal",
                  "external"
                )
            )
        ).as(:oneline),
        "link-mode" (
          ("automatic" | "half-duplex" | "full-duplex")
        ),
        "media-type" (
          ("copper" | "fiber")
        ),
        "encapsulation" (
          ("ethernet" | "fddi" | "token-ring" | "ppp" | "ppp-ccc" | "ppp-tcc" | "ether-vpls-ppp" | "frame-relay" | "frame-relay-ccc" | "frame-relay-tcc" | "extended-frame-relay-ccc" | "extended-frame-relay-tcc" | "flexible-frame-relay" | "frame-relay-port-ccc" | "frame-relay-ether-type" | "frame-relay-ether-type-tcc" | "extended-frame-relay-ether-type-tcc" | "cisco-hdlc" | "cisco-hdlc-ccc" | "cisco-hdlc-tcc" | "vlan-ccc" | "extended-vlan-ccc" | "ethernet-ccc" | "flexible-ethernet-services" | "smds-dxi" | "atm-pvc" | "atm-ccc-cell-relay" | "ethernet-over-atm" | "ethernet-tcc" | "extended-vlan-tcc" | "multilink-frame-relay-uni-nni" | "satop" | "cesopsn" | "ima" | "ethernet-vpls" | "ethernet-bridge" | "vlan-vpls" | "vlan-vci-ccc" | "extended-vlan-vpls" | "extended-vlan-bridge" | "multilink-ppp" | "generic-services")
        ),
        "esi" (
            c(
                  esi,
                c(
                  "single-active",
                  "all-active"
                ),
                "source-bmac" (
                  mac_unicast
                )
            )
        ),
        "framing" (
            c(
                c(
                  "lan-phy",
                  "wan-phy",
                  "sonet",
                  "sdh"
                )
            )
        ),
        "unidirectional",
        "lmi" (
            c(
                "n391dte" arg,
                "n392dce" arg,
                "n392dte" arg,
                "n393dce" arg,
                "n393dte" arg,
                "t391dte" arg,
                "t392dce" arg,
                "lmi-type" (
                  ("ansi" | "itu" | "c-lmi")
                )
            )
        ),
        "mlfr-uni-nni-bundle-options" (
            c(
                "cisco-interoperability" (
                    c(
                        "send-lip-remove-link-for-link-reject"
                    )
                ),
                "mrru" arg,
                "yellow-differential-delay" arg,
                "red-differential-delay" arg,
                "action-red-differential-delay" (
                  ("remove-link" | "disable-tx")
                ),
                "fragment-threshold" arg,
                "drop-timeout" arg,
                "link-layer-overhead" (
                  unsigned_float
                ),
                "lmi-type" (
                  ("ansi" | "itu" | "c-lmi")
                ),
                "minimum-links" arg,
                "hello-timer" arg,
                "acknowledge-timer" arg,
                "acknowledge-retries" arg,
                "n391" arg,
                "n392" arg,
                "n393" arg,
                "t391" arg,
                "t392" arg
            )
        ),
        "mac" (
          mac_unicast
        ),
        "receive-bucket" (
          dcd_rx_bucket_config
        ),
        "transmit-bucket" (
          dcd_tx_bucket_config
        ),
        "shared-interface",
        "sonet-options" (
          sonet_options_type
        ),
        "logical-tunnel-options" (
            c(
                "per-unit-mac-disable"
            )
        ),
        "aggregated-sonet-options" (
            c(
                "minimum-links" arg,
                "link-speed" (
                  ("oc3" | "oc12" | "oc48" | "oc192" | "oc768" | "mixed")
                ),
                "minimum-bandwidth" arg
            )
        ),
        "atm-options" (
            c(
                "pic-type" (
                  ("atm-ce" | "atm2" | "atm1")
                ),
                "cell-bundle-size" arg,
                "cell-bundle-timeout" arg,
                "plp-to-clp",
                "use-null-cw",
                "promiscuous-mode" (
                    c(
                        "vpi" arg.as(:oneline)
                    )
                ),
                "vpi" arg (
                    c(
                        "maximum-vcs" arg,
                        "shaping" (
                          dcd_shaping_config
                        ),
                        "oam-period" (
                            c(
                                c(
                                    arg,
                                  "disable".as(:oneline)
                                )
                            )
                        ).as(:oneline),
                        "oam-liveness" (
                            c(
                                "up-count" arg,
                                "down-count" arg
                            )
                        )
                    )
                ),
                "ilmi",
                "linear-red-profiles" arg (
                    c(
                        "queue-depth" arg,
                        "high-plp-threshold" arg,
                        "low-plp-threshold" arg,
                        "high-plp-max-threshold" arg,
                        "low-plp-max-threshold" arg
                    )
                ).as(:oneline),
                "scheduler-maps" arg (
                    c(
                        "vc-cos-mode" (
                          ("strict" | "alternate")
                        ),
                        "forwarding-class" arg (
                            c(
                                "priority" (
                                  ("low" | "high")
                                ),
                                "transmit-weight" (
                                    c(
                                        c(
                                          "percent" arg,
                                          "cells" arg
                                        )
                                    )
                                ).as(:oneline),
                                c(
                                  "epd-threshold" (
                                    epd_threshold_config
                                  ).as(:oneline),
                                  "linear-red-profile" arg
                                )
                            )
                        )
                    )
                ),
                "mpls" (
                  mpls_ifd_options
                ),
                "payload-scrambler",
                "no-payload-scrambler"
            )
        ),
        "multiservice-options" (
            c(
                "syslog",
                "no-syslog",
                "core-dump",
                "no-core-dump",
                "dump-on-flow-control",
                "no-dump-on-flow-control",
                "reset-on-flow-control",
                "no-reset-on-flow-control",
                "flow-control-options" (
                    c(
                        "dump-on-flow-control",
                        "reset-on-flow-control",
                        "down-on-flow-control"
                    )
                )
            )
        ),
        "ggsn-options" (
            c(
                "syslog",
                "no-syslog",
                "core-dump",
                "no-core-dump"
            )
        ),
        "ppp-options" (
          ppp_options_type
        ),
        "redundancy-options" (
            c(
                "primary" (
                  interface_device
                ),
                "secondary" (
                  interface_device
                ),
                "redundancy-peer" (
                    c(
                        "ipaddress" (
                          ipv4addr
                        )
                    )
                ),
                "redundancy-local" (
                    c(
                        "data-address" (
                          ipv4addr
                        )
                    )
                ),
                "routing-instance" arg,
                "replication-threshold" arg,
                "replication-options" (
                    c(
                        "mtu" arg
                    )
                ),
                "replicate-services" (
                    c(
                        "pgcp"
                    )
                )
            )
        ),
        "load-balancing-options" (
            c(
                "member-interface" arg,
                "member-failure-options" (
                    c(
                        c(
                          "redistribute-all-traffic" (
                              c(
                                  "enable-rejoin"
                              )
                          ),
                          "drop-member-traffic" (
                              c(
                                  "rejoin-timeout" arg,
                                  "enable-rejoin"
                              )
                          )
                        )
                    )
                ),
                "high-availability-options" (
                    c(
                        c(
                          "many-to-one" (
                              c(
                                  "preferred-backup" (
                                    interface_device
                                  )
                              )
                          ),
                          "one-to-one" (
                              c(
                                  "preferred-backup" (
                                    interface_device
                                  )
                              )
                          )
                        )
                    )
                )
            )
        ),
        "aggregated-inline-services-options" (
            c(
                "primary-interface" (
                  interface_device
                ),
                "secondary-interface" (
                  interface_device
                )
            )
        ),
        "anchoring-options" (
            c(
                "apfe-group-set" arg,
                "primary-list" arg,
                "secondary" (
                    c(
                        arg
                    )
                ),
                c(
                  "warm-standby"
                )
            )
        ),
        "lsq-failure-options" (
            c(
                "trigger-link-failure" arg,
                "no-termination-request",
                "no-no-termination-request"
            )
        ),
        "redundancy-group" (
            c(
                "member-interface" arg (
                    c(
                        c(
                          "active",
                          "backup"
                        )
                    )
                ),
                "maximum-links" arg
            )
        ),
        "services-options" (
            c(
                "syslog" (
                  service_set_syslog_object
                ),
                "jflow-log" (
                    c(
                        "message-rate-limit" arg
                    )
                ),
                "open-timeout" arg,
                "close-timeout" arg,
                "inactivity-timeout" arg,
                "inactivity-tcp-timeout" arg,
                "inactivity-asymm-tcp-timeout" arg,
                "inactivity-non-tcp-timeout" arg,
                "session-timeout" arg,
                "disable-global-timeout-override",
                "tcp-tickles" arg,
                "trio-flow-offload" (
                    c(
                        "minimum-bytes" arg
                    )
                ),
                "fragment-limit" arg,
                "reassembly-timeout" arg,
                "cgn-pic",
                "pba-interim-logging-interval" arg,
                "session-limit" (
                    c(
                        "maximum" arg,
                        "rate" arg,
                        "cpu-load-threshold" arg
                    )
                ),
                "ignore-errors" (
                    c(
                        "tcp",
                        "alg"
                    )
                ).as(:oneline),
                "capture" (
                    c(
                        "capture-size" arg,
                        "pkt-size" arg,
                        "logs-per-packet" arg,
                        "max-log-line-size" arg,
                        "filter" (
                            c(
                                "source-ip" (
                                    c(
                                          ipaddr,
                                        "wildcard" (
                                          ipaddr
                                        )
                                    )
                                ).as(:oneline),
                                "dest-ip" (
                                    c(
                                          ipaddr,
                                        "wildcard" (
                                          ipaddr
                                        )
                                    )
                                ).as(:oneline),
                                "sw-sip" (
                                    c(
                                          ipv6addr,
                                        "wildcard" (
                                          ipv6addr
                                        )
                                    )
                                ).as(:oneline),
                                "sw-dip" (
                                    c(
                                          ipaddr,
                                        "wildcard" (
                                          ipaddr
                                        )
                                    )
                                ).as(:oneline),
                                "sport-range" (
                                    c(
                                        "low" arg,
                                        "high" arg
                                    )
                                ).as(:oneline),
                                "dport-range" (
                                    c(
                                        "low" arg,
                                        "high" arg
                                    )
                                ).as(:oneline),
                                "proto" (
                                  ("icmp" | "tcp" | "udp")
                                )
                            )
                        )
                    )
                )
            )
        ),
        "t3-options" (
            c(
                "loopback" (
                  ("local" | "remote" | "payload")
                ),
                "long-buildout",
                "no-long-buildout",
                "loop-timing",
                "no-loop-timing",
                "unframed",
                "no-unframed",
                "compatibility-mode" (
                    c(
                        c(
                          "larscom" (
                              c(
                                  "subrate" arg
                              )
                          ).as(:oneline),
                          "verilink" (
                              c(
                                  "subrate" arg
                              )
                          ).as(:oneline),
                          "adtran" (
                              c(
                                  "subrate" arg
                              )
                          ).as(:oneline),
                          "kentrox" (
                              c(
                                  "subrate" arg
                              )
                          ).as(:oneline),
                          "digital-link" (
                              c(
                                  "subrate" (
                                    ("301Kb" | "601Kb" | "902Kb" | "1.2Mb" | "1.5Mb" | "1.8Mb" | "2.1Mb" | "2.4Mb" | "2.7Mb" | "3.0Mb" | "3.3Mb" | "3.6Mb" | "3.9Mb" | "4.2Mb" | "4.5Mb" | "4.8Mb" | "5.1Mb" | "5.4Mb" | "5.7Mb" | "6.0Mb" | "6.3Mb" | "6.6Mb" | "6.9Mb" | "7.2Mb" | "7.5Mb" | "7.8Mb" | "8.1Mb" | "8.4Mb" | "8.7Mb" | "9.0Mb" | "9.3Mb" | "9.6Mb" | "9.9Mb" | "10.2Mb" | "10.5Mb" | "10.8Mb" | "11.1Mb" | "11.4Mb" | "11.7Mb" | "12.0Mb" | "12.3Mb" | "12.6Mb" | "12.9Mb" | "13.2Mb" | "13.5Mb" | "13.8Mb" | "14.1Mb" | "14.4Mb" | "14.7Mb" | "15.0Mb" | "15.3Mb" | "15.6Mb" | "15.9Mb" | "16.2Mb" | "16.5Mb" | "16.8Mb" | "17.1Mb" | "17.4Mb" | "17.7Mb" | "18.0Mb" | "18.3Mb" | "18.6Mb" | "18.9Mb" | "19.2Mb" | "19.5Mb" | "19.8Mb" | "20.1Mb" | "20.5Mb" | "20.8Mb" | "21.1Mb" | "21.4Mb" | "21.7Mb" | "22.0Mb" | "22.3Mb" | "22.6Mb" | "22.9Mb" | "23.2Mb" | "23.5Mb" | "23.8Mb" | "24.1Mb" | "24.4Mb" | "24.7Mb" | "25.0Mb" | "25.3Mb" | "25.6Mb" | "25.9Mb" | "26.2Mb" | "26.5Mb" | "26.8Mb" | "27.1Mb" | "27.4Mb" | "27.7Mb" | "28.0Mb" | "28.3Mb" | "28.6Mb" | "28.9Mb" | "29.2Mb" | "29.5Mb" | "29.8Mb" | "30.1Mb" | "30.4Mb" | "30.7Mb" | "31.0Mb" | "31.3Mb" | "31.6Mb" | "31.9Mb" | "32.2Mb" | "32.5Mb" | "32.8Mb" | "33.1Mb" | "33.4Mb" | "33.7Mb" | "34.0Mb" | "34.3Mb" | "34.6Mb" | "34.9Mb" | "35.2Mb" | "35.5Mb" | "35.8Mb" | "36.1Mb" | "36.4Mb" | "36.7Mb" | "37.0Mb" | "37.3Mb" | "37.6Mb" | "37.9Mb" | "38.2Mb" | "38.5Mb" | "38.8Mb" | "39.1Mb" | "39.4Mb" | "39.7Mb" | "40.0Mb" | "40.3Mb" | "40.6Mb" | "40.9Mb" | "41.2Mb" | "41.5Mb" | "41.8Mb" | "42.1Mb" | "42.4Mb" | "42.7Mb" | "43.0Mb" | "43.3Mb" | "43.6Mb" | "43.9Mb" | "44.2Mb")
                                  )
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "payload-scrambler",
                "no-payload-scrambler",
                "cbit-parity",
                "no-cbit-parity",
                "fcs" (
                  ("32" | "16")
                ),
                "idle-cycle-flag" (
                  ("flags" | "ones")
                ),
                "start-end-flag" (
                  ("shared" | "filler")
                ),
                "feac-loop-respond",
                "no-feac-loop-respond",
                "bert-algorithm" (
                  ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                ),
                "bert-error-rate" arg,
                "bert-period" arg,
                "buildout" arg,
                "atm-encapsulation" (
                  ("plcp" | "direct")
                )
            )
        ),
        "e3-options" (
            c(
                "loopback" (
                  ("local" | "remote")
                ),
                "unframed",
                "no-unframed",
                "compatibility-mode" (
                    c(
                        c(
                          "larscom",
                          "digital-link" (
                              c(
                                  "subrate" (
                                    ("358Kb" | "716Kb" | "1.1Mb" | "1.4Mb" | "1.8Mb" | "2.1Mb" | "2.5Mb" | "2.9Mb" | "3.2Mb" | "3.6Mb" | "3.9Mb" | "4.3Mb" | "4.7Mb" | "5.0Mb" | "5.4Mb" | "5.7Mb" | "6.1Mb" | "6.4Mb" | "6.8Mb" | "7.2Mb" | "7.5Mb" | "7.9Mb" | "8.2Mb" | "8.6Mb" | "9.0Mb" | "9.3Mb" | "9.7Mb" | "10.0Mb" | "10.4Mb" | "10.7Mb" | "11.1Mb" | "11.5Mb" | "11.8Mb" | "12.2Mb" | "12.5Mb" | "12.9Mb" | "13.2Mb" | "13.6Mb" | "14.0Mb" | "14.3Mb" | "14.7Mb" | "15.0Mb" | "15.4Mb" | "15.8Mb" | "16.1Mb" | "16.5Mb" | "16.8Mb" | "17.2Mb" | "17.5Mb" | "17.9Mb" | "18.3Mb" | "18.6Mb" | "19.0Mb" | "19.3Mb" | "19.7Mb" | "20.0Mb" | "20.4Mb" | "20.8Mb" | "21.1Mb" | "21.5Mb" | "21.8Mb" | "22.2Mb" | "22.6Mb" | "22.9Mb" | "23.3Mb" | "23.6Mb" | "24.0Mb" | "24.3Mb" | "24.7Mb" | "25.1Mb" | "25.4Mb" | "25.8Mb" | "26.1Mb" | "26.5Mb" | "26.9Mb" | "27.2Mb" | "27.6Mb" | "27.9Mb" | "28.3Mb" | "28.6Mb" | "29.0Mb" | "29.4Mb" | "29.7Mb" | "30.1Mb" | "30.4Mb" | "30.8Mb" | "31.1Mb" | "31.5Mb" | "31.9Mb" | "32.2Mb" | "32.6Mb" | "32.9Mb" | "33.3Mb" | "33.7Mb" | "34.0Mb")
                                  )
                              )
                          ).as(:oneline),
                          "kentrox" (
                              c(
                                  "subrate" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "payload-scrambler",
                "no-payload-scrambler",
                "fcs" (
                  ("32" | "16")
                ),
                "idle-cycle-flag" (
                  ("flags" | "ones")
                ),
                "invert-data",
                "start-end-flag" (
                  ("shared" | "filler")
                ),
                "bert-algorithm" (
                  ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                ),
                "bert-error-rate" arg,
                "bert-period" arg,
                "buildout" arg,
                "atm-encapsulation" (
                  ("plcp" | "direct")
                ),
                "framing" (
                  ("g.751" | "g.832")
                )
            )
        ),
        "e1-options" (
            c(
                "timeslots" arg,
                "loopback" (
                  ("local" | "remote")
                ),
                "framing" (
                  ("g704" | "unframed" | "g704-no-crc4")
                ),
                "fcs" (
                  ("32" | "16")
                ),
                "invert-data",
                "idle-cycle-flag" (
                  ("flags" | "ones")
                ),
                "start-end-flag" (
                  ("shared" | "filler")
                ),
                "bert-algorithm" (
                  ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                ),
                "bert-error-rate" arg,
                "bert-period" arg
            )
        ),
        "t1-options" (
            c(
                "timeslots" arg,
                "voice-timeslots" arg,
                "disable-remote-alarm-detection" (
                  ("yellow")
                ),
                "loopback" (
                  ("local" | "remote" | "payload")
                ),
                "buildout" (
                  ("0-132" | "133-265" | "266-398" | "399-531" | "532-655" | "long-0db" | "long-7.5db" | "long-15db" | "long-22.5db")
                ),
                "byte-encoding" (
                  ("nx64" | "nx56")
                ),
                "line-encoding" (
                  ("ami" | "b8zs")
                ),
                "invert-data",
                "framing" (
                  ("sf" | "esf")
                ),
                "fcs" (
                  ("32" | "16")
                ),
                "idle-cycle-flag" (
                  ("flags" | "ones")
                ),
                "start-end-flag" (
                  ("shared" | "filler")
                ),
                "bert-algorithm" (
                  ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                ),
                "bert-error-rate" arg,
                "bert-period" arg,
                "remote-loopback-respond",
                "crc-major-alarm-threshold" (
                  ("1e-3" | "5e-4" | "1e-4" | "5e-5" | "1e-5")
                ),
                "crc-minor-alarm-threshold" (
                  ("1e-3" | "5e-4" | "1e-4" | "5e-5" | "1e-5" | "5e-6" | "1e-6")
                ),
                "alarm-compliance" (
                  ("accunet-t1-5-service")
                )
            )
        ),
        "ds0-options" (
            c(
                "loopback" (
                  ("payload")
                ),
                "byte-encoding" (
                  ("nx64" | "nx56")
                ),
                "invert-data",
                "fcs" (
                  ("32" | "16")
                ),
                "idle-cycle-flag" (
                  ("flags" | "ones")
                ),
                "start-end-flag" (
                  ("shared" | "filler")
                ),
                "bert-algorithm" (
                  ("pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4" | "repeating-1-in-16")
                ),
                "bert-error-rate" arg,
                "bert-period" arg
            )
        ),
        "serial-options" (
            c(
                "line-protocol" (
                  ("eia530" | "v.35" | "x.21")
                ),
                c(
                  "dte-options" (
                      c(
                          "ignore-all",
                          "dtr" (
                              c(
                                  c(
                                    "assert",
                                    "de-assert",
                                    "normal",
                                    "auto-synchronize" (
                                        c(
                                            "duration" arg,
                                            "interval" arg
                                        )
                                    )
                                  )
                              )
                          ).as(:oneline),
                          "control-signal" (
                            ("assert" | "de-assert" | "normal")
                          ),
                          "rts" (
                            ("assert" | "de-assert" | "normal")
                          ),
                          "dcd" (
                            ("require" | "ignore" | "normal")
                          ),
                          "dsr" (
                            ("require" | "ignore" | "normal")
                          ),
                          "cts" (
                            ("require" | "ignore" | "normal")
                          ),
                          "indication" (
                            ("require" | "ignore" | "normal")
                          ),
                          "tm" (
                            ("require" | "ignore" | "normal")
                          )
                      )
                  ),
                  "dce-options" (
                      c(
                          "ignore-all",
                          "dtr" (
                            ("require" | "ignore" | "normal")
                          ),
                          "rts" (
                            ("require" | "ignore" | "normal")
                          ),
                          "dcd" (
                            ("assert" | "de-assert" | "normal")
                          ),
                          "dsr" (
                            ("assert" | "de-assert" | "normal")
                          ),
                          "cts" (
                            ("assert" | "de-assert" | "normal")
                          ),
                          "tm" (
                            ("require" | "ignore" | "normal")
                          ),
                          "dce-loopback-override"
                      )
                  )
                ),
                "dtr-circuit" (
                  ("balanced" | "unbalanced")
                ),
                "dtr-polarity" (
                  ("positive" | "negative")
                ),
                "rts-polarity" (
                  ("positive" | "negative")
                ),
                "control-polarity" (
                  ("positive" | "negative")
                ),
                "dcd-polarity" (
                  ("positive" | "negative")
                ),
                "dsr-polarity" (
                  ("positive" | "negative")
                ),
                "cts-polarity" (
                  ("positive" | "negative")
                ),
                "indication-polarity" (
                  ("positive" | "negative")
                ),
                "tm-polarity" (
                  ("positive" | "negative")
                ),
                "clocking-mode" (
                  ("dce" | "internal" | "loop")
                ),
                "transmit-clock" (
                  ("invert")
                ),
                "clock-rate" (
                  ("2.048mhz" | "2.341mhz" | "2.731mhz" | "3.277mhz" | "4.096mhz" | "5.461mhz" | "8.192mhz" | "16.384mhz" | "1.2khz" | "2.4khz" | "9.6khz" | "19.2khz" | "38.4khz" | "56.0khz" | "64.0khz" | "72.0khz" | "125.0khz" | "148.0khz" | "250.0khz" | "500.0khz" | "800.0khz" | "1.0mhz" | "1.3mhz" | "2.0mhz" | "4.0mhz" | "8.0mhz")
                ),
                "loopback" (
                  ("local" | "remote" | "dce-local" | "dce-remote")
                ),
                "encoding" (
                  ("nrz" | "nrzi")
                ),
                "idle-cycle-flag" (
                  ("flags" | "ones")
                )
            )
        ),
        "gratuitous-arp-reply",
        "no-gratuitous-arp-reply",
        "no-gratuitous-arp-request",
        "no-no-gratuitous-arp-request",
        "arp-l2-validate",
        "ether-options" (
            c(
                "loopback",
                "no-loopback",
                "source-filtering",
                "no-source-filtering",
                "ethernet-switch-profile" (
                    c(
                        "tag-protocol-id" arg,
                        "ethernet-policer-profile" (
                            c(
                                "input-priority-map" (
                                  cos_policer_input_priority_map
                                ),
                                "output-priority-map" (
                                  cos_policer_output_priority_map
                                ),
                                "policer" (
                                  cos_policer
                                )
                            )
                        ),
                        "storm-control" (
                            c(
                                arg
                            )
                        ),
                        "recovery-timeout" (
                            c(
                                  arg
                            )
                        ).as(:oneline),
                        "mac-learn-enable",
                        "no-mac-learn-enable"
                    )
                ),
                "asynchronous-notification",
                "source-address-filter" arg.as(:oneline),
                "auto-negotiation",
                "no-auto-negotiation",
                "flow-control",
                "no-flow-control",
                "configured-flow-control" (
                    c(
                        "rx-buffers" (
                          ("on" | "off")
                        ),
                        "tx-buffers" (
                          ("on" | "off")
                        )
                    )
                ),
                "link-mode" (
                  ("automatic" | "half-duplex" | "full-duplex")
                ),
                "mpls" (
                  mpls_ifd_options
                ),
                "ignore-l3-incompletes",
                "no-auto-mdix",
                "speed" (
                    c(
                        c(
                          "auto-negotiation" (
                              c(
                                  "auto-negotiate-10-100"
                              )
                          ).as(:oneline),
                          "ethernet-10m",
                          "ethernet-100m",
                          "ethernet-1g",
                          "ethernet-10g"
                        )
                    )
                ),
                "ieee-802.3ad" (
                    c(
                        "lacp" (
                            c(
                                "force-up",
                                "port-priority" arg
                            )
                        ),
                          interface_device,
                        c(
                          "primary",
                          "backup"
                        ),
                        "link-protection-sub-group" (
                            c(
                                  arg
                            )
                        ),
                        "port-priority" arg
                    )
                ),
                "ieee-802-3az-eee",
                "mdi-mode" (
                  ("auto" | "force" | "mdi" | "mdix")
                ),
                "redundant-parent" (
                    c(
                          interface_device
                    )
                ),
                "autostate-exclude"
            )
        ),
        "fibrechannel-options" (
            c(
                "loopback",
                "no-loopback",
                "bb-sc-n" arg,
                "speed" (
                  ("auto-negotiation" | "1g" | "2g" | "4g" | "8g")
                )
            )
        ),
        "gigether-options" (
            c(
                "loopback",
                "no-loopback",
                "loopback-remote",
                "flow-control",
                "no-flow-control",
                "source-filtering",
                "no-source-filtering",
                c(
                  "no-auto-negotiation",
                  "auto-negotiation" (
                      c(
                          "remote-fault" (
                            ("local-interface-offline" | "local-interface-online")
                          )
                      )
                  ).as(:oneline)
                ),
                "mac-mode" (
                  ("sgmii" | "mac-mode-1000base-x")
                ),
                "asynchronous-notification",
                "source-address-filter" arg.as(:oneline),
                "pad-to-minimum-frame-size",
                "redundant-parent" (
                    c(
                          interface_device
                    )
                ),
                "ieee-802.3ad" (
                    c(
                        "lacp" (
                            c(
                                "port-priority" arg
                            )
                        ),
                          interface_device,
                        "link-index" arg,
                        c(
                          "primary",
                          "backup"
                        ),
                        "distribution-list" arg
                    )
                ),
                "ethernet-switch-profile" (
                    c(
                        "tag-protocol-id" arg,
                        "ethernet-policer-profile" (
                            c(
                                "ieee802.1-priority-map" (
                                    c(
                                        "premium" arg
                                    )
                                ),
                                "input-priority-map" (
                                  cos_policer_input_priority_map
                                ),
                                "output-priority-map" (
                                  cos_policer_output_priority_map
                                ),
                                "policer" (
                                  cos_policer
                                )
                            )
                        ),
                        "accept-from" (
                            c(
                                "mac-address" (
                                  mac_list
                                )
                            )
                        ),
                        "reject-the-rest",
                        "no-reject-the-rest",
                        "mac-learn-enable"
                    )
                ),
                "mpls" (
                  mpls_ifd_options
                ),
                "ignore-l3-incompletes",
                "no-auto-mdix",
                "ieee-802-3az-eee",
                "mru" arg,
                "fec" (
                  ("none" | "fec91" | "fec74")
                )
            )
        ),
        "optics-options" (
            c(
                "wavelength" (
                  ("1568.77" | "1568.36" | "1568.26" | "1568.16" | "1568.05" | "1567.95" | "1567.85" | "1567.75" | "1567.64" | "1567.54" | "1567.44" | "1567.34" | "1567.23" | "1567.13" | "1567.03" | "1566.93" | "1566.83" | "1566.72" | "1566.62" | "1566.52" | "1566.42" | "1566.31" | "1566.21" | "1566.11" | "1566.01" | "1565.90" | "1565.80" | "1565.70" | "1565.60" | "1565.50" | "1565.39" | "1565.29" | "1565.19" | "1565.09" | "1564.99" | "1564.88" | "1564.78" | "1564.68" | "1564.58" | "1564.47" | "1564.37" | "1564.27" | "1564.17" | "1564.07" | "1563.96" | "1563.86" | "1563.76" | "1563.66" | "1563.56" | "1563.45" | "1563.35" | "1563.25" | "1563.15" | "1563.05" | "1562.95" | "1562.84" | "1562.74" | "1562.64" | "1562.54" | "1562.44" | "1562.33" | "1562.23" | "1562.13" | "1562.03" | "1561.93" | "1561.83" | "1561.72" | "1561.62" | "1561.52" | "1561.42" | "1561.32" | "1561.22" | "1561.11" | "1561.01" | "1560.91" | "1560.81" | "1560.71" | "1560.61" | "1560.50" | "1560.40" | "1560.30" | "1560.20" | "1560.10" | "1560.00" | "1559.90" | "1559.79" | "1559.69" | "1559.59" | "1559.49" | "1559.39" | "1559.29" | "1559.19" | "1559.08" | "1558.98" | "1558.88" | "1558.78" | "1558.68" | "1558.58" | "1558.48" | "1558.38" | "1558.27" | "1558.17" | "1558.07" | "1557.97" | "1557.87" | "1557.77" | "1557.67" | "1557.57" | "1557.46" | "1557.36" | "1557.26" | "1557.16" | "1557.06" | "1556.96" | "1556.86" | "1556.76" | "1556.66" | "1556.55" | "1556.45" | "1556.35" | "1556.25" | "1556.15" | "1556.05" | "1555.95" | "1555.85" | "1555.75" | "1555.65" | "1555.55" | "1555.44" | "1555.34" | "1555.24" | "1555.14" | "1555.04" | "1554.94" | "1554.84" | "1554.74" | "1554.64" | "1554.54" | "1554.44" | "1554.34" | "1554.23" | "1554.13" | "1554.03" | "1553.93" | "1553.83" | "1553.73" | "1553.63" | "1553.53" | "1553.43" | "1553.33" | "1553.23" | "1553.13" | "1553.03" | "1552.93" | "1552.83" | "1552.73" | "1552.62" | "1552.52" | "1552.42" | "1552.32" | "1552.22" | "1552.12" | "1552.02" | "1551.92" | "1551.82" | "1551.72" | "1551.62" | "1551.52" | "1551.42" | "1551.32" | "1551.22" | "1551.12" | "1551.02" | "1550.92" | "1550.82" | "1550.72" | "1550.62" | "1550.52" | "1550.42" | "1550.32" | "1550.22" | "1550.12" | "1550.02" | "1549.92" | "1549.82" | "1549.72" | "1549.62" | "1549.52" | "1549.42" | "1549.32" | "1549.21" | "1549.11" | "1549.01" | "1548.91" | "1548.81" | "1548.71" | "1548.61" | "1548.51" | "1548.41" | "1548.31" | "1548.21" | "1548.11" | "1548.02" | "1547.92" | "1547.82" | "1547.72" | "1547.62" | "1547.52" | "1547.42" | "1547.32" | "1547.22" | "1547.12" | "1547.02" | "1546.92" | "1546.82" | "1546.72" | "1546.62" | "1546.52" | "1546.42" | "1546.32" | "1546.22" | "1546.12" | "1546.02" | "1545.92" | "1545.82" | "1545.72" | "1545.62" | "1545.52" | "1545.42" | "1545.32" | "1545.22" | "1545.12" | "1545.02" | "1544.92" | "1544.82" | "1544.72" | "1544.63" | "1544.53" | "1544.43" | "1544.33" | "1544.23" | "1544.13" | "1544.03" | "1543.93" | "1543.83" | "1543.73" | "1543.63" | "1543.53" | "1543.43" | "1543.33" | "1543.23" | "1543.13" | "1543.04" | "1542.94" | "1542.84" | "1542.74" | "1542.64" | "1542.54" | "1542.44" | "1542.34" | "1542.24" | "1542.14" | "1542.04" | "1541.94" | "1541.84" | "1541.75" | "1541.65" | "1541.55" | "1541.45" | "1541.35" | "1541.25" | "1541.15" | "1541.05" | "1540.95" | "1540.85" | "1540.76" | "1540.66" | "1540.56" | "1540.46" | "1540.36" | "1540.26" | "1540.16" | "1540.06" | "1539.96" | "1539.86" | "1539.77" | "1539.67" | "1539.57" | "1539.47" | "1539.37" | "1539.27" | "1539.17" | "1539.07" | "1538.98" | "1538.88" | "1538.78" | "1538.68" | "1538.58" | "1538.48" | "1538.38" | "1538.28" | "1538.19" | "1538.09" | "1537.99" | "1537.89" | "1537.79" | "1537.69" | "1537.59" | "1537.50" | "1537.40" | "1537.30" | "1537.20" | "1537.10" | "1537.00" | "1536.90" | "1536.81" | "1536.71" | "1536.61" | "1536.51" | "1536.41" | "1536.31" | "1536.22" | "1536.12" | "1536.02" | "1535.92" | "1535.82" | "1535.72" | "1535.63" | "1535.53" | "1535.43" | "1535.33" | "1535.23" | "1535.13" | "1535.04" | "1534.94" | "1534.84" | "1534.74" | "1534.64" | "1534.54" | "1534.45" | "1534.35" | "1534.25" | "1534.15" | "1534.05" | "1533.96" | "1533.86" | "1533.76" | "1533.66" | "1533.56" | "1533.47" | "1533.37" | "1533.27" | "1533.17" | "1533.07" | "1532.98" | "1532.88" | "1532.78" | "1532.68" | "1532.58" | "1532.49" | "1532.39" | "1532.29" | "1532.19" | "1532.09" | "1532.00" | "1531.90" | "1531.80" | "1531.70" | "1531.60" | "1531.51" | "1531.41" | "1531.31" | "1531.21" | "1531.12" | "1531.02" | "1530.92" | "1530.82" | "1530.72" | "1530.63" | "1530.53" | "1530.43" | "1530.33" | "1530.24" | "1530.14" | "1530.04" | "1529.94" | "1529.85" | "1529.75" | "1529.65" | "1529.55" | "1529.46" | "1529.36" | "1529.26" | "1529.16" | "1529.07" | "1528.97" | "1528.87" | "1528.77" | "1528.38")
                ),
                "tx-power" arg,
                "loopback",
                "los-warning-threshold" arg,
                "los-alarm-threshold" arg,
                "modulation-format" (
                  ("16qam" | "8qam" | "qpsk")
                ),
                "laser-enable",
                "no-laser-enable",
                "is-ma",
                "no-is-ma",
                "encoding" (
                  ("differential" | "non-differential")
                ),
                "fec" (
                  ("sdfec" | "sdfec25")
                ),
                "alarm" (("low-light-alarm")) (
                    c(
                        c(
                          "syslog",
                          "link-down"
                        )
                    )
                ),
                "tca" (
                    c(
                        "tx-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "tx-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "rx-power-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "rx-power-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "temperature-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "temperature-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "carrier-frequency-offset-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "carrier-frequency-offset-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "fec-ber" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ).as(:oneline),
                        "tec-current-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "tec-current-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "residual-isi-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "residual-isi-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "pam-histogram-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "snr-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "fec-corrected-errors-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "fec-ucorrected-words-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "laser-frequency-error-high-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        ),
                        "laser-frequency-error-low-tca" (
                            c(
                                "enable-tca",
                                "no-enable-tca",
                                "threshold" arg,
                                "threshold-24hrs" arg
                            )
                        )
                    )
                ),
                "warning" (("low-light-warning")) (
                    c(
                        c(
                          "syslog",
                          "link-down"
                        )
                    )
                )
            )
        ),
        "otn-options" (
          otn_options_type
        ),
        "fastether-options" (
            c(
                "loopback",
                "no-loopback",
                "flow-control",
                "no-flow-control",
                "source-filtering",
                "no-source-filtering",
                "auto-negotiation",
                "no-auto-negotiation",
                "ingress-rate-limit" arg,
                "source-address-filter" arg.as(:oneline),
                "redundant-parent" (
                    c(
                          interface_device
                    )
                ),
                "ieee-802.3ad" (
                    c(
                        "lacp" (
                            c(
                                "port-priority" arg
                            )
                        ),
                          interface_device,
                        c(
                          "primary",
                          "backup"
                        )
                    )
                ),
                "mpls" (
                  mpls_ifd_options
                ),
                "ignore-l3-incompletes"
            )
        ),
        "redundant-ether-options" (
            c(
                "redundancy-group" arg,
                "loopback",
                "no-loopback",
                "flow-control",
                "no-flow-control",
                "source-filtering",
                "no-source-filtering",
                "source-address-filter" arg.as(:oneline),
                "link-speed" (
                  ("10m" | "100m" | "1g" | "10g")
                ),
                "minimum-links" arg,
                "lacp" (
                    c(
                        c(
                          "active",
                          "passive"
                        ),
                        "periodic" (
                          ("fast" | "slow")
                        )
                    )
                )
            )
        ),
        "aggregated-ether-options" (
            c(
                "loopback",
                "no-loopback",
                "flow-control",
                "no-flow-control",
                "source-filtering",
                "no-source-filtering",
                "autostate-exclude",
                "link-protection" (
                    c(
                        "revertive",
                        "backup-state" (
                          ("accept-data" | "discard-data" | "down")
                        )
                    )
                ),
                "fcoe-lag",
                "no-fcoe-lag",
                "source-address-filter" arg.as(:oneline),
                "configured-flow-control" (
                    c(
                        "rx-buffers" (
                          ("on" | "off")
                        ),
                        "tx-buffers" (
                          ("on" | "off")
                        )
                    )
                ),
                "load-balance" (
                  aggregate_load_balance
                ),
                "bfd-liveness-detection" (
                    c(
                        "version" (
                          ("0" | "1" | "automatic")
                        ),
                        "minimum-interval" arg,
                        "minimum-transmit-interval" arg,
                        "minimum-receive-interval" arg,
                        "multiplier" arg,
                        c(
                          "no-adaptation"
                        ),
                        "transmit-interval" (
                            c(
                                "minimum-interval" arg,
                                "threshold" arg
                            )
                        ),
                        "detection-time" (
                            c(
                                "threshold" arg
                            )
                        ),
                        "authentication" (
                            c(
                                "key-chain" arg,
                                "algorithm" (
                                  ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                ),
                                "loose-check"
                            )
                        ),
                        "neighbor" (
                          ipaddr
                        ),
                        "local-address" (
                          ipaddr
                        ),
                        "holddown-interval" arg
                    )
                ),
                "minimum-links" arg,
                "minimum-bandwidth" (
                    c(
                        "bw-value" arg,
                        "bw-unit" (
                          ("bps" | "kbps" | "mbps" | "gbps")
                        )
                    )
                ),
                "targeted-options" (
                    c(
                        "type" (
                          ("auto" | "manual")
                        ),
                        c(
                          "logical-interface-fpc-redundancy",
                          "logical-interface-chassis-redundancy"
                        ),
                        "rebalance-periodic" (
                            c(
                                "start-time" (
                                  time
                                ),
                                "interval" arg
                            )
                        ),
                        "rebalance-subscriber-granularity" arg
                    )
                ),
                c(
                  "logical-interface-fpc-redundancy",
                  "logical-interface-chassis-redundancy"
                ),
                "rebalance-periodic" (
                    c(
                        "start-time" (
                          time
                        ),
                        "interval" arg
                    )
                ),
                "pad-to-minimum-frame-size",
                "link-speed" (
                  ("10m" | "100m" | "1g" | "8g" | "10g" | "25g" | "40g" | "50g" | "80g" | "100g" | "oc192" | "mixed")
                ),
                "local-bias" (
                    c(
                        "disable"
                    )
                ),
                "local-minimum-links-threshold" arg,
                "resilient-hash",
                "lacp" (
                    c(
                        c(
                          "active",
                          "passive"
                        ),
                        "periodic" (
                          ("fast" | "slow")
                        ),
                        "fast-failover",
                        "link-protection" (
                            c(
                                "disable",
                                c(
                                  "revertive",
                                  "non-revertive"
                                )
                            )
                        ),
                        "accept-data",
                        "sync-reset" (
                          ("disable" | "enable")
                        ),
                        "system-priority" arg,
                        "system-id" (
                          mac_addr
                        ),
                        "admin-key" arg,
                        "hold-time" (
                            c(
                                "up" arg
                            )
                        ).as(:oneline),
                        "aggregate-wait-time" arg,
                        "force-up"
                    )
                ),
                "link-protection-sub-group" arg (
                    c(
                        c(
                          "primary",
                          "backup"
                        )
                    )
                ),
                "ethernet-switch-profile" (
                    c(
                        "tag-protocol-id" arg,
                        "storm-control" (
                            c(
                                arg
                            )
                        ),
                        "mac-learn-enable"
                    )
                ),
                "mc-ae" (
                    c(
                        "mc-ae-id" arg,
                        "redundancy-group" arg,
                        "chassis-id" arg,
                        "mode" (
                          ("active-standby" | "active-active")
                        ),
                        "status-control" (
                          ("active" | "standby")
                        ),
                        "switchover-mode" (
                          ("revertive" | "non-revertive")
                        ),
                        "revert-time" arg,
                        "init-delay-time" arg,
                        "recovery-delay-time" arg,
                        "enhanced-convergence",
                        "events" (
                            c(
                                "iccp-peer-down" (
                                    c(
                                        "force-icl-down",
                                        "prefer-status-control-active"
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ),
        "es-options" (
            c(
                "backup-interface" (
                  interface_device
                )
            )
        ),
        "dsl-options" (
            c(
                "operating-mode" (
                  ("auto" | "ansi-dmt" | "itu-dmt" | "etsi" | "itu-annexb-ur2" | "itu-annexb-non-ur2" | "itu-dmt-bis" | "adsl2plus" | "annexm-itu-dmt-bis" | "annexm-adsl2plus")
                )
            )
        ),
        "vdsl-options" (
            c(
                "vdsl-profile" (
                  ("auto" | "8a" | "8b" | "8c" | "8d" | "12a" | "12b" | "17a")
                ),
                "sra" (
                  ("enable" | "disable")
                ),
                "v43" (
                  ("enable" | "disable")
                )
            )
        ),
        "shdsl-options" (
            c(
                "annex" (
                  ("annex-a" | "annex-b" | "annex-f" | "annex-g" | "annex-auto")
                ),
                "line-rate" (
                  ("auto" | arg)
                ),
                "loopback" (
                  ("local" | "remote")
                ),
                "snr-margin" (
                    c(
                        "current" (
                          ("disable" | arg)
                        ),
                        "snext" (
                          ("disable" | arg)
                        )
                    )
                )
            )
        ),
        "data-input" (
            c(
                c(
                  "system",
                  "interface" (
                    interface_device
                  )
                )
            )
        ),
        "switch-options" (
            c(
                "switch-port" arg (
                    c(
                        "auto-negotiation",
                        "no-auto-negotiation",
                        "link-mode" (
                          ("half-duplex" | "full-duplex")
                        ),
                        "speed" (
                          ("10m" | "100m" | "1g")
                        ),
                        "vlan-id" arg,
                        "cascade-port"
                    )
                )
            )
        ),
        "container-options" (
            c(
                "container-type" (
                    c(
                        c(
                          "aps" (
                            aps_type
                          )
                        )
                    )
                ),
                "member-interface-type" (
                    c(
                        c(
                          "sonet" (
                              c(
                                  "member-interface-speed" (
                                    ("oc3" | "oc12" | "oc48" | "oc192" | "oc768" | "mixed")
                                  )
                              )
                          ),
                          "atm" (
                              c(
                                  "member-interface-speed" (
                                    ("oc3" | "oc12" | "oc48")
                                  )
                              )
                          ),
                          "channelized-sonet" (
                              c(
                                  "member-interface-speed" (
                                    ("coc3" | "coc12" | "coc48" | "coc192" | "coc768")
                                  )
                              )
                          ),
                          "channelized-sdh" (
                              c(
                                  "member-interface-speed" (
                                    ("cstm1" | "cstm4" | "cstm16" | "coc64" | "cstm256")
                                  )
                              )
                          )
                        )
                    )
                ),
                "redundancy" (
                    c(
                        "hold-time" (
                            c(
                                "up" arg,
                                "down" arg
                            )
                        ).as(:oneline)
                    )
                ),
                "container-list" (
                  interface_device
                ),
                c(
                    "primary",
                    "standby"
                ),
                "fast-aps",
                "allow-configuration-override"
            )
        ),
        "layer2-policer" (
            c(
                c(
                  "input-policer" arg,
                  "input-hierarchical-policer" arg
                )
            )
        ),
        "unit" (("$junos-underlying-interface-unit" | "$junos-interface-unit" | arg)) (
            c(
                "policer-overhead" (
                    c(
                          arg,
                        "ingress" arg,
                        "egress" arg
                    )
                ),
                "alias" arg,
                "enhanced-convergence",
                "proxy-macip-advertisement",
                "peer-psd" (
                    c(
                        arg
                    )
                ).as(:oneline),
                "peer-interface" (
                    c(
                          interface_unit
                    )
                ),
                "interface-shared-with" (
                    c(
                        arg
                    )
                ),
                  ("disable"),
                "passive-monitor-mode",
                "per-session-scheduler",
                "account-layer2-overhead" (
                    c(
                          arg,
                        "ingress" arg,
                        "egress" arg
                    )
                ),
                "forwarding-class-accounting" (
                    c(
                        "direction" (
                          ("ingress" | "egress" | "both")
                        ),
                        "enhanced" (
                            c(
                                "traffic-type" (
                                  ("unicast-statistics" | "multicast-statistics")
                                ),
                                "family" (
                                  ("inet" | "inet6" | "both")
                                ),
                                "direction" (
                                  ("ingress" | "egress" | "both")
                                ),
                                "overhead-bytes" arg
                            )
                        )
                    )
                ),
                "clear-dont-fragment-bit",
                "packet-inject-enable",
                "reassemble-packets",
                "services-options",
                "rpm" (
                    c(
                        c(
                          c(
                            "client",
                            "server"
                          ),
                          "twamp-server",
                          "twamp-client"
                        )
                    )
                ),
                "description" arg,
                "metadata" arg,
                "dial-options" (
                    c(
                        c(
                          "l2tp-interface-id" arg,
                          "ipsec-interface-id" arg
                        ),
                        c(
                          "dedicated",
                          "shared"
                        )
                    )
                ),
                "actual-transit-statistics",
                "demux-source" (
                      (("inet" | "inet6"))
                ),
                "demux-destination" (
                      (("inet" | "inet6"))
                ),
                "encapsulation" (
                  ("atm-nlpid" | "atm-cisco-nlpid" | "atm-snap" | "atm-vc-mux" | "atm-ccc-vc-mux" | "atm-tcc-vc-mux" | "atm-tcc-snap" | "atm-ccc-cell-relay" | "vlan-vci-ccc" | "ether-over-atm-llc" | "ether-vpls-over-atm-llc" | "ppp-over-ether-over-atm-llc" | "ppp-over-ether" | "atm-ppp-vc-mux" | "atm-ppp-llc" | "atm-mlppp-llc" | "frame-relay-ppp" | "frame-relay-ccc" | "frame-relay" | "frame-relay-tcc" | "frame-relay-ether-type" | "frame-relay-ether-type-tcc" | "ether-vpls-fr" | "vlan-ccc" | "ethernet-ccc" | "vlan-vpls" | "vlan-bridge" | "dix" | "ethernet" | "ethernet-vpls" | "ethernet-bridge" | "vlan" | "vlan-tcc" | "multilink-ppp" | "multilink-frame-relay-end-to-end" | "ppp-ccc")
                ),
                "gre",
                "mtu" arg,
                c(
                  "point-to-point",
                  "multipoint"
                ),
                "bandwidth" arg,
                "global-layer2-domainid" arg,
                "radio-router" (
                  dynamic_ifbw_parms_type
                ),
                "traps",
                "no-traps",
                "routing-services",
                "no-routing-services",
                "arp-resp" (
                    c(
                        c(
                          "unrestricted",
                          "restricted"
                        )
                    )
                ).as(:oneline),
                "proxy-arp" (
                    c(
                        c(
                          "unrestricted",
                          "restricted"
                        )
                    )
                ).as(:oneline),
                c(
                  "vlan-id" (
                    ("none" | arg)
                  ),
                  "vlan-id-range" arg,
                  "inner-vlan-id-swap-ranges" arg,
                  "vlan-id-list" arg,
                  "vlan-tag" arg,
                  "vlan-tags" (
                      c(
                          "outer" (
                            ("$junos-stacked-vlan-id" | "$junos-vlan-id" | arg)
                          ),
                          c(
                            "inner" (
                              ("$junos-vlan-id" | arg)
                            ),
                            "inner-range" arg,
                            "inner-list" arg
                          )
                      )
                  ).as(:oneline)
                ),
                "native-inner-vlan-id" arg,
                "inner-vlan-id-range" (
                    c(
                        "start" arg,
                        "end" arg
                    )
                ).as(:oneline),
                "accept-source-mac" (
                    c(
                        "mac-address" (
                          mac_list
                        )
                    )
                ),
                "input-vlan-map" (
                  vlan_map
                ),
                "output-vlan-map" (
                  vlan_map
                ),
                "swap-by-poppush",
                "receive-lsp" arg,
                "transmit-lsp" arg,
                "dlci" arg,
                "multicast-dlci" arg,
                c(
                  "vci" (
                    atm_vci
                  ),
                  "allow-any-vci",
                  "vpi" arg,
                  "trunk-id" arg
                ),
                "no-vpivci-swapping",
                c(
                  "psn-vci" (
                    atm_vci
                  ),
                  "psn-vpi" arg
                ),
                "atm-l2circuit-mode" (
                    c(
                        c(
                          "cell",
                          "aal5"
                        )
                    )
                ).as(:oneline),
                "vci-range" (
                    c(
                        "start" arg,
                        "end" arg
                    )
                ).as(:oneline),
                "trunk-bandwidth" arg,
                "multicast-vci" (
                  atm_vci
                ),
                "shaping" (
                  dcd_shaping_config
                ),
                "oam-period" (
                    c(
                        c(
                            arg,
                          "disable".as(:oneline)
                        )
                    )
                ).as(:oneline),
                "oam-liveness" (
                    c(
                        "up-count" arg,
                        "down-count" arg
                    )
                ),
                "ppp-options" (
                  ppp_options_type
                ),
                "pppoe-options" (
                  pppoe_options_type
                ),
                "pppoe-underlying-options" (
                  pppoe_underlying_options_type
                ),
                "advisory-options" (
                  advisory_options_type
                ),
                "auto-configure" (
                  auto_configure_vlan_type
                ),
                "demux-options" (
                  demux_options_type
                ),
                "targeted-distribution" (
                    c(
                        "primary-list" arg,
                        "backup-list" arg,
                        "standby-list" arg
                    )
                ),
                "targeted-options" (
                    c(
                        "primary" (
                          interface_device
                        ),
                        "backup" (
                          interface_device
                        ),
                        "group" arg
                    )
                ),
                c(
                  "keepalives" (
                    keepalives_type
                  ).as(:oneline),
                  "no-keepalives"
                ),
                "inverse-arp",
                "transmit-weight" arg,
                "epd-threshold" (
                  epd_threshold_config
                ).as(:oneline),
                "cell-bundle-size" arg,
                "cell-bundle-timeout" arg,
                "plp-to-clp",
                "atm-scheduler-map" arg,
                "mrru" arg,
                "short-sequence",
                "fragment-threshold" arg,
                "drop-timeout" arg,
                "disable-mlppp-inner-ppp-pfc",
                "minimum-links" arg,
                "multilink-max-classes" arg,
                "compression" (
                    c(
                        "rtp" (
                            c(
                                "f-max-period" arg,
                                "queues" (
                                  ("q0" | "q1" | "q2" | "q3")
                                ),
                                "port" (
                                    c(
                                        "minimum" arg,
                                        "maximum" arg
                                    )
                                ).as(:oneline),
                                "maximum-contexts" (
                                    c(
                                          arg
                                    )
                                ).as(:oneline)
                            )
                        )
                    )
                ),
                "interleave-fragments",
                "link-layer-overhead" (
                  unsigned_float
                ),
                "accounting-profile" arg,
                "peer-unit" arg,
                "tunnel" (
                    c(
                        "source" (
                          ipaddr
                        ),
                        "destination" (
                          ipaddr
                        ),
                        "key" arg,
                        "backup-destination" (
                          ipaddr
                        ),
                        c(
                          "allow-fragmentation",
                          "do-not-fragment"
                        ),
                        "ttl" arg,
                        "traffic-class" arg,
                        "flow-label" arg,
                        "path-mtu-discovery",
                        "no-path-mtu-discovery",
                        "routing-instance" (
                            c(
                                "destination" arg
                            )
                        )
                    )
                ),
                "compression-device" (
                  interface_unit
                ),
                "atm-policer" (
                    c(
                        "input-atm-policer" arg
                    )
                ),
                "layer2-policer" (
                    c(
                        c(
                          "input-policer" arg,
                          "input-hierarchical-policer" arg,
                          "input-three-color" arg
                        ),
                        c(
                          "output-policer" (
                            ("$junos-layer2-output-policer" | arg)
                          ),
                          "output-three-color" (
                            ("$junos-layer2-output-policer" | arg)
                          )
                        )
                    )
                ),
                "filter" (
                    c(
                        c(
                          "input" (
                              c(
                                  arg,
                                  "shared-name" arg,
                                  "precedence" arg
                              )
                          ).as(:oneline)
                        ),
                        c(
                          "output" (
                              c(
                                  arg,
                                  "shared-name" arg,
                                  "precedence" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ),
                "multi-chassis-protection" (
                  multi_chassis_protection_group_ifl
                ),
                "statistics",
                "esi" (
                    c(
                          esi,
                        c(
                          "single-active",
                          "all-active"
                        )
                    )
                ),
                "virtual-gateway-esi" (
                    c(
                          esi,
                        c(
                          "single-active",
                          "all-active"
                        )
                    )
                ),
                "service" (
                    c(
                        "pcef" arg (
                            c(
                                "activate-all",
                                "activate" arg
                            )
                        )
                    )
                ),
                "family" (
                    c(
                        "inet" (
                            c(
                                "dhcp" (
                                  dhcp_client_type
                                ),
                                "targeted-broadcast" (
                                    c(
                                        c(
                                          "forward-and-send-to-re",
                                          "forward-only"
                                        )
                                    )
                                ),
                                "destination-class-usage",
                                "transit-options-packets",
                                "transit-ttl-exceeded",
                                "receive-options-packets",
                                "receive-ttl-exceeded",
                                "accounting" (
                                    c(
                                        "source-class-usage" (
                                            c(
                                                "input",
                                                "output"
                                            )
                                        ),
                                        "destination-class-usage"
                                    )
                                ),
                                "mac-validate" (
                                  ("strict" | "loose")
                                ),
                                "rpf-check" (
                                    c(
                                        "fail-filter" arg,
                                        "mode" (
                                            c(
                                                "loose"
                                            )
                                        ).as(:oneline)
                                    )
                                ),
                                "mtu" arg,
                                "arp-max-cache" arg,
                                "arp-new-hold-limit" arg,
                                "tcp-mss" arg,
                                "no-redirects",
                                "no-neighbor-learn",
                                "unconditional-src-learn",
                                "multicast-only",
                                "primary",
                                "ipsec-sa" arg,
                                "allow-filter-on-re",
                                "demux-source" ("$junos-subscriber-ip-address" | arg),
                                "demux-destination" ("$junos-subscriber-ip-address" | arg),
                                "filter" (
                                    c(
                                        c(
                                          "input" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline),
                                          "input-list" arg
                                        ),
                                        c(
                                          "output" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline),
                                          "output-list" arg
                                        ),
                                        "adf" (
                                            c(
                                                "rule" arg,
                                                "counter",
                                                "input-precedence" arg,
                                                "not-mandatory",
                                                "output-precedence" arg
                                            )
                                        ),
                                        "group" arg
                                    )
                                ),
                                "ingress-queuing-filter" (
                                    c(
                                        arg
                                    )
                                ).as(:oneline),
                                "simple-filter" (
                                    c(
                                        "input" arg
                                    )
                                ),
                                "input-hierarchical-policer" arg,
                                "policer" (
                                    c(
                                        "arp" arg,
                                        "input" arg,
                                        "output" arg
                                    )
                                ),
                                "sampling" (
                                    c(
                                        "input",
                                        "output"
                                    )
                                ),
                                "service" (
                                    c(
                                        "input" (
                                            c(
                                                "service-set" arg (
                                                    c(
                                                        "service-filter" arg
                                                    )
                                                ),
                                                "post-service-filter" arg
                                            )
                                        ),
                                        "output" (
                                            c(
                                                "service-set" arg (
                                                    c(
                                                        "service-filter" arg
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "next-hop-tunnel" arg (
                                    c(
                                        "ipsec-vpn" arg
                                    )
                                ),
                                "address" arg (
                                    c(
                                        "destination" (
                                          ipv4addr
                                        ),
                                        "destination-profile" arg,
                                        "broadcast" (
                                          ipv4addr
                                        ),
                                        "primary",
                                        "preferred",
                                        "master-only",
                                        "multipoint-destination" arg (
                                            c(
                                                c(
                                                  "dlci" arg,
                                                  "vci" (
                                                    atm_vci
                                                  )
                                                ),
                                                "shaping" (
                                                  dcd_shaping_config
                                                ),
                                                "oam-period" (
                                                    c(
                                                        c(
                                                            arg,
                                                          "disable".as(:oneline)
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "oam-liveness" (
                                                    c(
                                                        "up-count" arg,
                                                        "down-count" arg
                                                    )
                                                ),
                                                "inverse-arp",
                                                "transmit-weight" arg,
                                                "epd-threshold" (
                                                  epd_threshold_config
                                                ).as(:oneline)
                                            )
                                        ),
                                        "arp" arg (
                                            c(
                                                "l2-interface" (
                                                  interface_name
                                                ),
                                                c(
                                                  "mac" (
                                                    mac_unicast
                                                  ),
                                                  "multicast-mac" (
                                                    mac_multicast
                                                  )
                                                ),
                                                "publish"
                                            )
                                        ).as(:oneline),
                                        "web-authentication" (
                                            c(
                                                "http",
                                                "https",
                                                "redirect-to-https"
                                            )
                                        ),
                                        "vrrp-group" (
                                          vrrp_group
                                        ),
                                        "virtual-gateway-address" (
                                          ipv4addr
                                        )
                                    )
                                ),
                                "unnumbered-address" (
                                    c(
                                          interface_unit,
                                        "preferred-source-address" (
                                          ("$junos-preferred-source-address" | arg)
                                        ),
                                        "destination" (
                                          ipv4addr
                                        ),
                                        "destination-profile" arg
                                    )
                                ).as(:oneline),
                                "location-pool-address" (
                                    c(
                                          arg
                                    )
                                ),
                                "negotiate-address"
                            )
                        ),
                        "iso" (
                            c(
                                "address" arg,
                                "mtu" arg
                            )
                        ),
                        "inet6" (
                            c(
                                "dhcpv6-client" (
                                    c(
                                        "client-type" (
                                          ("stateful" | "autoconfig")
                                        ),
                                        "client-ia-type" (("ia-na" | "ia-pd")),
                                        "rapid-commit",
                                        "client-identifier" (
                                            c(
                                                "duid-type" (
                                                  ("duid-llt" | "vendor" | "duid-ll")
                                                )
                                            )
                                        ).as(:oneline),
                                        "req-option" (("dns-server" | "domain" | "ntp-server" | "time-zone" | "sip-server" | "sip-domain" | "nis-server" | "nis-domain" | "fqdn" | "vendor-spec")),
                                        "retransmission-attempt" arg,
                                        "no-dns-propagation",
                                        "update-router-advertisement" (
                                            c(
                                                "interface" arg (
                                                    c(
                                                        "managed-configuration",
                                                        "no-managed-configuration",
                                                        "other-stateful-configuration",
                                                        "no-other-stateful-configuration",
                                                        "max-advertisement-interval" arg,
                                                        "min-advertisement-interval" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "update-server"
                                    )
                                ),
                                "rpf-check" (
                                    c(
                                        "fail-filter" arg,
                                        "mode" (
                                            c(
                                                "loose"
                                            )
                                        ).as(:oneline)
                                    )
                                ),
                                "accounting" (
                                    c(
                                        "source-class-usage" (
                                            c(
                                                "input",
                                                "output"
                                            )
                                        ),
                                        "destination-class-usage"
                                    )
                                ),
                                "mtu" arg,
                                "tcp-mss" arg,
                                "nd6-stale-time" arg,
                                "no-neighbor-learn",
                                "nd6-max-cache" arg,
                                "nd6-new-hold-limit" arg,
                                "no-redirects",
                                "allow-filter-on-re",
                                "filter" (
                                    c(
                                        c(
                                          "input" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline),
                                          "input-list" arg
                                        ),
                                        c(
                                          "output" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline),
                                          "output-list" arg
                                        ),
                                        "adf" (
                                            c(
                                                "rule" arg,
                                                "counter",
                                                "input-precedence" arg,
                                                "not-mandatory",
                                                "output-precedence" arg
                                            )
                                        ),
                                        "group" arg
                                    )
                                ),
                                "ingress-queuing-filter" (
                                    c(
                                        arg
                                    )
                                ).as(:oneline),
                                "input-hierarchical-policer" arg,
                                "policer" (
                                    c(
                                        "input" arg,
                                        "output" arg
                                    )
                                ),
                                "sampling" (
                                    c(
                                        "input",
                                        "output"
                                    )
                                ),
                                "service" (
                                    c(
                                        "input" (
                                            c(
                                                "service-set" arg (
                                                    c(
                                                        "service-filter" arg
                                                    )
                                                ),
                                                "post-service-filter" arg
                                            )
                                        ),
                                        "output" (
                                            c(
                                                "service-set" arg (
                                                    c(
                                                        "service-filter" arg
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "address" arg (
                                    c(
                                        "destination" (
                                          ipv6addr
                                        ),
                                        "eui-64",
                                        "primary",
                                        "preferred",
                                        "master-only",
                                        "ndp" arg (
                                            c(
                                                "l2-interface" (
                                                  interface_name
                                                ),
                                                c(
                                                  "mac" (
                                                    mac_unicast
                                                  ),
                                                  "multicast-mac" (
                                                    mac_multicast
                                                  )
                                                ),
                                                "publish"
                                            )
                                        ).as(:oneline),
                                        "vrrp-inet6-group" (
                                          vrrp_group
                                        ),
                                        "web-authentication" (
                                            c(
                                                "http",
                                                "https",
                                                "redirect-to-https"
                                            )
                                        ),
                                        "virtual-gateway-address" (
                                          ipv6addr
                                        ),
                                        "subnet-router-anycast"
                                    )
                                ),
                                "demux-source" ("$junos-subscriber-ipv6-address" | arg | "$junos-subscriber-ipv6-multi-address"),
                                "demux-destination" ("$junos-subscriber-ipv6-address" | arg),
                                "unnumbered-address" (
                                    c(
                                          interface_unit,
                                        "preferred-source-address" (
                                          ("$junos-preferred-source-ipv6-address" | arg)
                                        )
                                    )
                                ).as(:oneline),
                                "dad-disable",
                                "no-dad-disable"
                            )
                        ),
                        "mpls" (
                            c(
                                "mtu" arg,
                                "maximum-labels" arg,
                                "filter" (
                                    c(
                                        c(
                                          "input" arg,
                                          "input-list" arg
                                        ),
                                        c(
                                          "output" arg,
                                          "output-list" arg
                                        ),
                                        "group" arg
                                    )
                                ),
                                "ingress-queuing-filter" (
                                    c(
                                        arg
                                    )
                                ).as(:oneline),
                                "input-hierarchical-policer" arg,
                                "policer" (
                                    c(
                                        "input" arg,
                                        "output" arg
                                    )
                                )
                            )
                        ),
                        "mlppp" (
                            c(
                                "bundle" (
                                  ("$junos-bundle-interface-name" | arg)
                                ),
                                c(
                                  "service-interface" (
                                    interface_device
                                  ),
                                  "service-device-pool" arg
                                ),
                                "dynamic-profile" arg
                            )
                        ),
                        "mlfr-end-to-end" (
                            c(
                                "bundle" (
                                  interface_unit
                                )
                            )
                        ),
                        "mlfr-uni-nni" (
                            c(
                                "bundle" (
                                  interface_unit
                                )
                            )
                        ),
                        "ccc" (
                            c(
                                "mtu" arg,
                                "filter" (
                                    c(
                                        c(
                                          "input" arg,
                                          "input-list" arg
                                        ),
                                        c(
                                          "output" arg,
                                          "output-list" arg
                                        ),
                                        "group" arg
                                    )
                                ),
                                "ingress-queuing-filter" (
                                    c(
                                        arg
                                    )
                                ).as(:oneline),
                                "policer" (
                                    c(
                                        "input" arg,
                                        "output" arg
                                    )
                                ),
                                "translate-fecn-and-becn",
                                c(
                                  "translate-discard-eligible",
                                  "translate-plp-control-word-de"
                                ),
                                "keep-address-and-control"
                            )
                        ),
                        "tcc" (
                            c(
                                "policer" (
                                    c(
                                        "input" arg,
                                        "output" arg
                                    )
                                ),
                                "proxy" (
                                    c(
                                        "inet-address" (
                                          ipv4addr
                                        )
                                    )
                                ),
                                "remote" (
                                    c(
                                        "inet-address" (
                                          ipv4addr
                                        ),
                                        "mac-address" (
                                          mac_addr
                                        )
                                    )
                                ),
                                "protocols" (
                                  ("mpls" | "inet" | "iso")
                                )
                            )
                        ),
                        "vpls" (
                            c(
                                "core-facing",
                                "filter" (
                                    c(
                                        c(
                                          "input" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline),
                                          "input-list" arg
                                        ),
                                        c(
                                          "output" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline),
                                          "output-list" arg
                                        ),
                                        "adf" (
                                            c(
                                                "rule" arg,
                                                "counter",
                                                "input-precedence" arg,
                                                "not-mandatory",
                                                "output-precedence" arg
                                            )
                                        ),
                                        "group" arg
                                    )
                                ),
                                "ingress-queuing-filter" (
                                    c(
                                        arg
                                    )
                                ).as(:oneline),
                                "policer" (
                                    c(
                                        "input" arg,
                                        "output" arg
                                    )
                                )
                            )
                        ),
                        "bridge" (
                            c(
                                "core-facing",
                                "filter" (
                                    c(
                                        c(
                                          "input" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline),
                                          "input-list" arg
                                        ),
                                        c(
                                          "output" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline),
                                          "output-list" arg
                                        ),
                                        "adf" (
                                            c(
                                                "rule" arg,
                                                "counter",
                                                "input-precedence" arg,
                                                "not-mandatory",
                                                "output-precedence" arg
                                            )
                                        ),
                                        "group" arg
                                    )
                                ),
                                "ingress-queuing-filter" (
                                    c(
                                        arg
                                    )
                                ).as(:oneline),
                                "policer" (
                                    c(
                                        "input" arg,
                                        "output" arg
                                    )
                                ),
                                "interface-mode" (
                                  ("access" | "trunk")
                                ),
                                "vlan-auto-sense",
                                "bridge-domain-type" (
                                  ("svlan" | "bvlan")
                                ),
                                "inter-switch-link",
                                c(
                                  "vlan-id" arg,
                                  "vlan-id-list" arg,
                                  "inner-vlan-id-list" arg
                                ),
                                "vlan-rewrite" (
                                    c(
                                        "translate" arg (
                                            c(
                                                  arg
                                            )
                                        ).as(:oneline)
                                    )
                                ),
                                c(
                                  "isid-list" (
                                    ("all-service-groups" | "all")
                                  )
                                ),
                                "storm-control" (
                                    c(
                                        arg
                                    )
                                ),
                                "recovery-timeout" (
                                    c(
                                          arg
                                    )
                                ).as(:oneline)
                            )
                        ),
                        "ethernet-switching" (
                          ethernet_switching_type
                        ),
                        "fibre-channel" (
                          fibre_channel_type
                        ),
                        "pppoe" (
                          pppoe_underlying_options_type
                        ),
                        "any" (
                            c(
                                "filter" (
                                    c(
                                        "input" arg,
                                        "group" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "service-domain" (
                  ("inside" | "outside")
                ),
                "copy-tos-to-outer-ip-header",
                "copy-tos-to-outer-ip-header-transit",
                "load-balancing-options" (
                    c(
                        "preferred-active" (
                          interface_device
                        ),
                        "hash-keys" (
                            c(
                                "ingress-key" (
                                      (("source-ip" | "destination-ip" | "protocol" | "iif"))
                                ),
                                "egress-key" (
                                      (("source-ip" | "destination-ip" | "protocol" | "oif"))
                                )
                            )
                        )
                    )
                ),
                "mac" (
                  mac_unicast
                ),
                "virtual-gateway-v4-mac" (
                  mac_unicast
                ),
                "virtual-gateway-v6-mac" (
                  mac_unicast
                ),
                "forwarding-options" (
                    c(
                        "load-balance-stateful" (
                            c(
                                "per-flow",
                                "rebalance" arg,
                                "load-type" (
                                  ("high" | "medium" | "low")
                                )
                            )
                        )
                    )
                ),
                "etree-ac-role" (
                  ("root" | "leaf")
                )
            )
        ),
        "no-partition" (
            c(
                "interface-type" (
                  ("e1" | "t1" | "at" | "t3" | "e3" | "ct3" | "so" | "cau4")
                )
            )
        ).as(:oneline),
        "partition" arg (
            c(
                "oc-slice" arg,
                "timeslots" arg,
                "interface-type" (
                  ("ds" | "e1" | "t1" | "at" | "ct1" | "ce1" | "t3" | "ct3" | "e3" | "so" | "coc1" | "cau4" | "dc" | "bc")
                )
            )
        ).as(:oneline),
        "radius-options" (
          radius_options_vlan_type
        )
    )
  )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:juniper_bd_protocols_mld_snooping) do
    c(
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("packets" | "query" | "report" | "leave" | "group" | "client-notification" | "host-notification" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                    c(
                        "send",
                        "receive",
                        "detail",
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "query-interval" arg,
        "query-response-interval" arg,
        "query-last-member-interval" arg,
        "robust-count" arg,
        "immediate-leave",
        "proxy" (
            c(
                "source-address" (
                  ipv6addr
                ),
                "irb"
            )
        ),
        "interface" arg (
            c(
                "multicast-router-interface",
                "immediate-leave",
                "host-only-interface",
                "group-limit" arg,
                "static" (
                    c(
                        "group" arg (
                            c(
                                "source" arg
                            )
                        )
                    )
                )
            )
        ),
        "pseudowire-remote-address" arg (
            c(
                "multicast-router-interface",
                "immediate-leave"
            )
        ),
        "vlan" arg (
            c(
                "query-interval" arg,
                "query-response-interval" arg,
                "query-last-member-interval" arg,
                "robust-count" arg,
                "immediate-leave",
                "proxy" (
                    c(
                        "source-address" (
                          ipv6addr
                        )
                    )
                ),
                "interface" arg (
                    c(
                        "multicast-router-interface",
                        "immediate-leave",
                        "host-only-interface",
                        "group-limit" arg,
                        "static" (
                            c(
                                "group" arg (
                                    c(
                                        "source" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "pseudowire-remote-address" arg (
                    c(
                        "multicast-router-interface",
                        "immediate-leave"
                    )
                ),
                "qualified-vlan" arg (
                    c(
                        "query-interval" arg,
                        "query-response-interval" arg,
                        "query-last-member-interval" arg,
                        "robust-count" arg,
                        "immediate-leave",
                        "proxy" (
                            c(
                                "source-address" (
                                  ipv6addr
                                )
                            )
                        ),
                        "interface" arg (
                            c(
                                "multicast-router-interface",
                                "immediate-leave",
                                "host-only-interface",
                                "group-limit" arg,
                                "static" (
                                    c(
                                        "group" arg (
                                            c(
                                                "source" arg
                                            )
                                        )
                                    )
                                )
                            )
                        ),
                        "pseudowire-remote-address" arg (
                            c(
                                "multicast-router-interface",
                                "immediate-leave"
                            )
                        )
                    )
                )
            )
        )
    )
end

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

rule(:jdhcp_relay_type) do
    c(
        "traceoptions" (
          jdhcp_traceoptions_type
        ),
        "persistent-storage" (
            c(
                "automatic"
            )
        ).as(:oneline),
        "duplicate-clients-on-interface",
        "duplicate-clients-in-subnet" (
          jdhcp_duplicate_clients_in_subnet_type
        ).as(:oneline),
        "interface-traceoptions" (
          jdhcp_interface_traceoptions_type
        ),
        "dhcpv6" (
          dhcpv6_relay_type
        ),
        "arp-inspection",
        "forward-snooped-clients" (
            c(
                c(
                  "configured-interfaces",
                  "non-configured-interfaces",
                  "all-interfaces"
                )
            )
        ).as(:oneline),
        "authentication" (
          authentication_type
        ),
        "liveness-detection" (
          dhcp_liveness_detection_type
        ),
        "dynamic-profile" (
          dynamic_profile_type
        ).as(:oneline),
        "service-profile" arg,
        "access-profile" arg,
        "overrides" (
          override_type
        ),
        "relay-option" (
          dhcp_generic_v4_option
        ),
        "relay-option-60" (
          relay_option_60_type_top
        ),
        "relay-option-82" (
          relay_option_82_type
        ),
        "forward-only" (
          forward_only_to_rc_type
        ),
        "vpn",
        "forward-only-replies",
        "server-group" (
          server_group_type
        ),
        "active-server-group" (
          dhcpv4_gbl_active_sg_type
        ),
        "route-suppression" (
          dhcp_route_suppression_type
        ),
        "group" (
          dhcp_group
        ),
        "dual-stack-group" (
          dhcp_dual_stack_group
        ),
        "no-snoop",
        "server-response-time" arg,
        "lease-time-validation" (
            c(
                "lease-time-threshold" arg,
                "violation-action" (
                    c(
                        "drop"
                    )
                ).as(:oneline)
            )
        ),
        "leasequery" (
          relay_leasequery_type
        ),
        "bulk-leasequery" (
          relay_bulk_leasequery_v4_type
        ),
        "remote-id-mismatch" (
          dhcp_remote_id_mismatch_type
        )
    )
end

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

rule(:dhcp_dual_stack_group) do
  arg.as(:arg) (
    c(
        "authentication" (
          dual_stack_authentication_type
        ),
        "service-profile" arg,
        "access-profile" arg,
        "dynamic-profile" (
          dynamic_profile_type
        ).as(:oneline),
        "relay-agent-interface-id" (
          v6_relay_option_interface_id_type
        ),
        "relay-agent-remote-id" (
          v6_relay_option_remote_id_type
        )
    )
  )
end

rule(:dhcp_generic_v4_option) do
    c(
        "option-number" (
          ("60" | "77")
        ),
        "equals" (
          relay_v4_option_ascii_hex
        ),
        "default-action" (
          dhcp_v4_option_default_action
        ),
        "starts-with" (
          relay_v4_option_ascii_hex
        )
    )
end

rule(:dhcp_group) do
  arg.as(:arg) (
    c(
        "active-server-group" (
          dhcpv4_gp_active_sg_type
        ),
        "authentication" (
          authentication_type
        ),
        "liveness-detection" (
          dhcp_liveness_detection_type
        ),
        "dynamic-profile" (
          dynamic_profile_type
        ).as(:oneline),
        "service-profile" arg,
        "access-profile" arg,
        "overrides" (
          override_type
        ),
        "relay-option" (
          dhcp_generic_v4_option
        ),
        "relay-option-60" (
          relay_option_60_type_group
        ),
        "relay-option-82" (
          relay_option_82_type
        ),
        "forward-only" (
          forward_only_to_rc_type
        ),
        "route-suppression" (
          dhcp_route_suppression_type
        ),
        "vpn",
        "interface" arg (
            c(
                "upto" (
                  interface_name
                ),
                "exclude",
                "trace",
                "overrides" (
                  override_type
                ),
                "dynamic-profile" (
                  dynamic_profile_type
                ).as(:oneline),
                "service-profile" arg,
                "access-profile" arg
            )
        ),
        "remote-id-mismatch" (
          dhcp_remote_id_mismatch_type
        ),
        "lease-time-validation" (
            c(
                "lease-time-threshold" arg,
                "violation-action" (
                    c(
                        "drop"
                    )
                ).as(:oneline)
            )
        )
    )
  )
end

rule(:dhcp_liveness_detection_type) do
    c(
        "failure-action" (
          dhcp_liveness_detection_failure_action_type
        ).as(:oneline),
        "method" (
            c(
                c(
                  "bfd" (
                    dhcp_bfd_liveness_detection_type
                  )
                )
            )
        )
    )
end

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

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

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

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

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

rule(:dhcpv4_gbl_active_sg_type) do
    c(
          arg,
        "allow-server-change"
    ).as(:oneline)
end

rule(:dhcpv4_gp_active_sg_type) do
    c(
          arg,
        "allow-server-change"
    ).as(:oneline)
end

rule(:dhcpv6_relay_type) do
    c(
        "authentication" (
          dhcpv6_authentication_type
        ),
        "persistent-storage" (
            c(
                "automatic"
            )
        ).as(:oneline),
        "liveness-detection" (
          dhcpv6_liveness_detection_type
        ),
        "dynamic-profile" (
          dynamic_profile_type
        ).as(:oneline),
        "service-profile" arg,
        "access-profile" arg,
        "overrides" (
          dhcpv6_override_relay_type
        ),
        "relay-option" (
          dhcp_generic_v6_option
        ),
        "vendor-specific-information" (
          jdhcp_vendor_specific_type
        ),
        "forward-only" (
          forward_only_to_rc_type
        ),
        "forward-only-replies",
        "forward-snooped-clients" (
            c(
                c(
                  "configured-interfaces",
                  "non-configured-interfaces",
                  "all-interfaces"
                )
            )
        ).as(:oneline),
        "route-suppression" (
          dhcpv6_route_suppression_type
        ),
        "group" (
          dhcpv6_relay_group
        ),
        "relay-agent-interface-id" (
          v6_relay_option_interface_id_type
        ),
        "relay-agent-remote-id" (
          v6_relay_option_remote_id_type
        ),
        "server-group" (
          v6_server_group_type
        ),
        "active-server-group" (
          dhcpv6_gbl_active_sg_type
        ),
        "server-response-time" arg,
        "lease-time-validation" (
            c(
                "lease-time-threshold" arg,
                "violation-action" (
                    c(
                        "drop"
                    )
                ).as(:oneline)
            )
        ),
        "no-snoop",
        "leasequery" (
          relay_leasequery_type
        ),
        "bulk-leasequery" (
          relay_bulk_leasequery_v6_type
        ),
        "remote-id-mismatch" (
          dhcp_remote_id_mismatch_type
        ),
        "duplicate-clients" (
          dhcpv6_duplicate_clients_type
        ).as(:oneline)
    )
end

rule(:dhcp_generic_v6_option) do
    c(
        "option-number" (
          ("15" | "16")
        ),
        "equals" (
          relay_v6_option_ascii_hex
        ),
        "default-action" (
          dhcp_v6_option_default_action
        ),
        "starts-with" (
          relay_v6_option_ascii_hex
        )
    )
end

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

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

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

rule(:dhcpv6_gbl_active_sg_type) do
    c(
          arg
    )
end

rule(:dhcpv6_liveness_detection_type) do
    c(
        "failure-action" (
          dhcp_liveness_detection_failure_action_type
        ).as(:oneline),
        "method" (
            c(
                c(
                  "bfd" (
                    dhcp_bfd_liveness_detection_type
                  )
                )
            )
        )
    )
end

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

rule(:dhcpv6_relay_group) do
  arg.as(:arg) (
    c(
        "active-server-group" (
          dhcpv6_gp_active_sg_type
        ),
        "dual-stack-group" (
          dhcp_dual_stack_group
        ),
        "authentication" (
          dhcpv6_authentication_type
        ),
        "liveness-detection" (
          dhcpv6_liveness_detection_type
        ),
        "dynamic-profile" (
          dynamic_profile_type
        ).as(:oneline),
        "service-profile" arg,
        "access-profile" arg,
        "overrides" (
          dhcpv6_override_relay_type
        ),
        "relay-option" (
          dhcp_generic_v6_option
        ),
        "vendor-specific-information" (
          jdhcp_vendor_specific_type
        ),
        "forward-only" (
          forward_only_to_rc_type
        ),
        "relay-agent-interface-id" (
          v6_relay_option_interface_id_type
        ),
        "relay-agent-remote-id" (
          v6_relay_option_remote_id_type
        ),
        "route-suppression" (
          dhcpv6_route_suppression_type
        ),
        "interface" arg (
            c(
                "upto" (
                  interface_name
                ),
                "exclude",
                "trace",
                "overrides" (
                  dhcpv6_override_relay_type
                ),
                "dynamic-profile" (
                  dynamic_profile_type
                ).as(:oneline),
                "service-profile" arg,
                "access-profile" arg
            )
        ),
        "lease-time-validation" (
            c(
                "lease-time-threshold" arg,
                "violation-action" (
                    c(
                        "drop"
                    )
                ).as(:oneline)
            )
        ),
        "remote-id-mismatch" (
          dhcp_remote_id_mismatch_type
        )
    )
  )
end

rule(:dhcpv6_gp_active_sg_type) do
    c(
          arg
    )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:juniper_charging_profiles) do
  arg.as(:arg) (
    c(
        "description" arg,
        "profile-id" arg,
        "default-service-id" arg,
        "default-rating-group" arg,
        "default-l7-rating-group" arg,
        "transport-profile" (
            c(
                  arg
            )
        ),
        "cdr-profile" (
            c(
                  arg
            )
        ),
        "diameter-avp-profile" (
            c(
                  arg
            )
        ),
        "trigger-profile" arg (
            c(
                "rating-group" arg
            )
        ),
        "service-mode" (
          ("maintenance")
        )
    )
  )
end

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

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

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

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

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

rule(:juniper_def_rtb_auto_import_as) do
    c(
        "import-as" arg (
            c(
                "vni-list" arg
            )
        )
    )
end

rule(:juniper_diameter_avp_profiles) do
  arg.as(:arg) (
    c(
        "description" arg,
        "exclude-avp-options" (
            c(
                "ps-information",
                "user-location-3gpp",
                "framed-v4-address",
                "gprs-negotiated-qos",
                "username",
                "user-equip-info",
                "all-3gpp-avps",
                "qos-information",
                "pdn-connection-id",
                "dynamic-address-flag",
                "serving-node-type",
                "charging-charact-select-mode",
                "start-time",
                "stop-time"
            )
        )
    )
  )
end

rule(:juniper_dynamic_profile_object) do
  arg.as(:arg) (
    c(
        "variables" (
          juniper_dynamic_variable_object
        ),
        "predefined-variable-defaults" (
            c(
                "cos-excess-rate" (
                    c(
                        "proportion" arg,
                        "percent" arg
                    )
                ),
                "cos-excess-rate-high" (
                    c(
                        "proportion" arg,
                        "percent" arg
                    )
                ),
                "cos-excess-rate-low" (
                    c(
                        "proportion" arg,
                        "percent" arg
                    )
                ),
                "cos-scheduler-tx" (
                    c(
                        "rate" arg,
                        "percent" arg
                    )
                ),
                "cos-scheduler-bs" (
                    c(
                        "percent" arg,
                        "temporal" arg
                    )
                ),
                "cos-scheduler-shaping-rate" (
                    c(
                        "rate" arg,
                        "percent" arg
                    )
                ),
                  base_default_variable_object
            )
        ),
        "routing-instances" (
            c(
                    c(
                        "interface" ("$junos-interface-name" | arg) (
                            c(
                                c(
                                  "any",
                                  "unicast",
                                  "multicast"
                                ),
                                "primary"
                            )
                        ),
                        "routing-options" (
                            c(
                                "rib" arg (
                                    c(
                                        "static" (
                                            c(
                                                "rib-group" arg,
                                                "defaults" (
                                                    c(
                                                        "retain",
                                                        "no-retain",
                                                        "install",
                                                        "no-install",
                                                        "readvertise",
                                                        "no-readvertise",
                                                        "resolve",
                                                        "no-resolve",
                                                        "longest-match",
                                                        "no-longest-match",
                                                        c(
                                                          "active",
                                                          "passive"
                                                        ),
                                                        "metric" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric3" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric4" (
                                                          rib_static_metric_type
                                                        ),
                                                        "tag" (
                                                          rib_static_metric_type
                                                        ),
                                                        "tag2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "preference" (
                                                          rib_static_metric_type
                                                        ),
                                                        "preference2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "color" (
                                                          rib_static_metric_type
                                                        ),
                                                        "color2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "community" (
                                                          community
                                                        ),
                                                        "as-path" (
                                                            c(
                                                                "path" arg,
                                                                "origin" (
                                                                  ("igp" | "egp" | "incomplete")
                                                                ),
                                                                "atomic-aggregate",
                                                                "aggregator" (
                                                                    c(
                                                                        arg,
                                                                          ipv4addr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                ),
                                                "route" arg (
                                                    c(
                                                        c(
                                                          "next-hop" (
                                                            ipaddr_or_interface
                                                          ),
                                                          "reject",
                                                          "discard",
                                                          "receive",
                                                          "next-table" arg
                                                        ),
                                                        "qualified-next-hop" (
                                                          qualified_nh_obj
                                                        ),
                                                        "lsp-next-hop" (
                                                          lsp_nh_obj
                                                        ),
                                                        "static-lsp-next-hop" (
                                                          lsp_nh_obj
                                                        ),
                                                        "p2mp-lsp-next-hop" (
                                                          lsp_nh_obj
                                                        ),
                                                        "p2mp-ldp-next-hop" (
                                                          p2mp_ldp_lsp_nh_obj
                                                        ),
                                                        "backup-pe-group" arg,
                                                        "bfd-liveness-detection" (
                                                            c(
                                                                "version" (
                                                                  ("0" | "1" | "automatic")
                                                                ),
                                                                "minimum-interval" arg,
                                                                "minimum-transmit-interval" arg,
                                                                "minimum-receive-interval" arg,
                                                                "multiplier" arg,
                                                                c(
                                                                  "no-adaptation"
                                                                ),
                                                                "transmit-interval" (
                                                                    c(
                                                                        "minimum-interval" arg,
                                                                        "threshold" arg
                                                                    )
                                                                ),
                                                                "detection-time" (
                                                                    c(
                                                                        "threshold" arg
                                                                    )
                                                                ),
                                                                "authentication" (
                                                                    c(
                                                                        "key-chain" arg,
                                                                        "algorithm" (
                                                                          ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                                                        ),
                                                                        "loose-check"
                                                                    )
                                                                ),
                                                                "neighbor" (
                                                                  ipaddr
                                                                ),
                                                                "local-address" (
                                                                  ipaddr
                                                                ),
                                                                "holddown-interval" arg,
                                                                "minimum-receive-ttl" arg
                                                            )
                                                        ),
                                                        "retain",
                                                        "no-retain",
                                                        "install",
                                                        "no-install",
                                                        "readvertise",
                                                        "no-readvertise",
                                                        "resolve",
                                                        "no-resolve",
                                                        "longest-match",
                                                        "no-longest-match",
                                                        c(
                                                          "active",
                                                          "passive"
                                                        ),
                                                        "metric" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric3" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric4" (
                                                          rib_static_metric_type
                                                        ),
                                                        "tag" (
                                                          rib_static_metric_type
                                                        ),
                                                        "tag2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "preference" (
                                                          rib_static_metric_type
                                                        ),
                                                        "preference2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "color" (
                                                          rib_static_metric_type
                                                        ),
                                                        "color2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "community" (
                                                          community
                                                        ),
                                                        "as-path" (
                                                            c(
                                                                "path" arg,
                                                                "origin" (
                                                                  ("igp" | "egp" | "incomplete")
                                                                ),
                                                                "atomic-aggregate",
                                                                "aggregator" (
                                                                    c(
                                                                        arg,
                                                                          ipv4addr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                ),
                                                "static-route" (
                                                    c(
                                                        "bfd-admin-down" (
                                                          ("active" | "passive")
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "iso-route" arg (
                                                    c(
                                                        c(
                                                          "next-hop" (
                                                            ipaddr_or_interface
                                                          ),
                                                          "reject",
                                                          "discard",
                                                          "receive",
                                                          "next-table" arg
                                                        ),
                                                        "qualified-next-hop" (
                                                          qualified_nh_obj
                                                        ),
                                                        "lsp-next-hop" (
                                                          lsp_nh_obj
                                                        ),
                                                        "static-lsp-next-hop" (
                                                          lsp_nh_obj
                                                        ),
                                                        "p2mp-lsp-next-hop" (
                                                          lsp_nh_obj
                                                        ),
                                                        "p2mp-ldp-next-hop" (
                                                          p2mp_ldp_lsp_nh_obj
                                                        ),
                                                        "backup-pe-group" arg,
                                                        "bfd-liveness-detection" (
                                                            c(
                                                                "version" (
                                                                  ("0" | "1" | "automatic")
                                                                ),
                                                                "minimum-interval" arg,
                                                                "minimum-transmit-interval" arg,
                                                                "minimum-receive-interval" arg,
                                                                "multiplier" arg,
                                                                c(
                                                                  "no-adaptation"
                                                                ),
                                                                "transmit-interval" (
                                                                    c(
                                                                        "minimum-interval" arg,
                                                                        "threshold" arg
                                                                    )
                                                                ),
                                                                "detection-time" (
                                                                    c(
                                                                        "threshold" arg
                                                                    )
                                                                ),
                                                                "authentication" (
                                                                    c(
                                                                        "key-chain" arg,
                                                                        "algorithm" (
                                                                          ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                                                        ),
                                                                        "loose-check"
                                                                    )
                                                                ),
                                                                "neighbor" (
                                                                  ipaddr
                                                                ),
                                                                "local-address" (
                                                                  ipaddr
                                                                ),
                                                                "holddown-interval" arg,
                                                                "minimum-receive-ttl" arg
                                                            )
                                                        ),
                                                        "retain",
                                                        "no-retain",
                                                        "install",
                                                        "no-install",
                                                        "readvertise",
                                                        "no-readvertise",
                                                        "resolve",
                                                        "no-resolve",
                                                        "longest-match",
                                                        "no-longest-match",
                                                        c(
                                                          "active",
                                                          "passive"
                                                        ),
                                                        "metric" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric3" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric4" (
                                                          rib_static_metric_type
                                                        ),
                                                        "tag" (
                                                          rib_static_metric_type
                                                        ),
                                                        "tag2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "preference" (
                                                          rib_static_metric_type
                                                        ),
                                                        "preference2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "color" (
                                                          rib_static_metric_type
                                                        ),
                                                        "color2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "community" (
                                                          community
                                                        ),
                                                        "as-path" (
                                                            c(
                                                                "path" arg,
                                                                "origin" (
                                                                  ("igp" | "egp" | "incomplete")
                                                                ),
                                                                "atomic-aggregate",
                                                                "aggregator" (
                                                                    c(
                                                                        arg,
                                                                          ipv4addr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                ),
                                                "route-target-filter" arg (
                                                    c(
                                                        "neighbor" (
                                                          ipaddr
                                                        ),
                                                        "group" arg,
                                                        "local"
                                                    )
                                                )
                                            )
                                        ),
                                        "martians" (
                                          martian_type
                                        ),
                                        "aggregate" (
                                          rib_aggregate_type
                                        ),
                                        "generate" (
                                          rib_aggregate_type
                                        ),
                                        c(
                                          "maximum-routes" (
                                              c(
                                                    arg,
                                                  c(
                                                    "threshold" arg,
                                                    "log-only"
                                                  ),
                                                  "log-interval" arg
                                              )
                                          ).as(:oneline),
                                          "maximum-paths" (
                                              c(
                                                    arg,
                                                  c(
                                                    "threshold" arg,
                                                    "log-only"
                                                  ),
                                                  "log-interval" arg
                                              )
                                          ).as(:oneline)
                                        ),
                                        "maximum-prefixes" (
                                            c(
                                                  arg,
                                                c(
                                                  "threshold" arg,
                                                  "log-only"
                                                ),
                                                "log-interval" arg
                                            )
                                        ).as(:oneline),
                                        "multipath" (
                                            c(
                                                "vpn-unequal-cost" (
                                                    c(
                                                        "equal-external-internal"
                                                    )
                                                ).as(:oneline),
                                                "as-path-compare"
                                            )
                                        ),
                                        "protect" (
                                            c(
                                                "core"
                                            )
                                        ).as(:oneline),
                                        "label" (
                                            c(
                                                "allocation" (
                                                  policy_algebra
                                                ),
                                                "substitution" (
                                                  policy_algebra
                                                )
                                            )
                                        ),
                                        "access" (
                                            c(
                                                "route" arg (
                                                    c(
                                                        "next-hop" (
                                                          ipaddr_or_interface
                                                        ),
                                                        "qualified-next-hop" (
                                                          qualified_nh_obj
                                                        ),
                                                        "metric" arg,
                                                        "preference" arg,
                                                        "tag" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "access-internal" (
                                            c(
                                                "route" arg (
                                                    c(
                                                        "next-hop" (
                                                          ipaddr_or_interface
                                                        ),
                                                        "qualified-next-hop" (
                                                          qualified_nh_obj
                                                        )
                                                    )
                                                )
                                            )
                                        ),
                                        "bgp-static" (
                                            c(
                                                "route" arg (
                                                    c(
                                                        "metric" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric3" (
                                                          rib_static_metric_type
                                                        ),
                                                        "metric4" (
                                                          rib_static_metric_type
                                                        ),
                                                        "tag" (
                                                          rib_static_metric_type
                                                        ),
                                                        "tag2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "preference" (
                                                          rib_static_metric_type
                                                        ),
                                                        "preference2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "color" (
                                                          rib_static_metric_type
                                                        ),
                                                        "color2" (
                                                          rib_static_metric_type
                                                        ),
                                                        "community" (
                                                          community
                                                        ),
                                                        "as-path" (
                                                            c(
                                                                "path" arg,
                                                                "origin" (
                                                                  ("igp" | "egp" | "incomplete")
                                                                ),
                                                                "atomic-aggregate",
                                                                "aggregator" (
                                                                    c(
                                                                        arg,
                                                                          ipv4addr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        ),
                                        "flow" (
                                            c(
                                                "validation" (
                                                  flow_validation
                                                ),
                                                "route" (
                                                  flow_route_inet6
                                                ),
                                                "interface-group" (
                                                  flow_interface_group
                                                )
                                            )
                                        )
                                    )
                                ),
                                "access" (
                                    c(
                                        "route" arg (
                                            c(
                                                "next-hop" (
                                                  ipaddr_or_interface
                                                ),
                                                "qualified-next-hop" (
                                                  qualified_nh_obj
                                                ),
                                                "metric" arg,
                                                "preference" arg,
                                                "tag" arg
                                            )
                                        )
                                    )
                                ),
                                "access-internal" (
                                    c(
                                        "route" arg (
                                            c(
                                                "next-hop" (
                                                  ipaddr_or_interface
                                                ),
                                                "qualified-next-hop" (
                                                  qualified_nh_obj
                                                )
                                            )
                                        )
                                    )
                                ),
                                "multicast" (
                                    c(
                                        "traceoptions" (
                                            c(
                                                "file" (
                                                  trace_file_type
                                                ),
                                                "flag" (("parse" | "config-internal" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                                                    c(
                                                        "disable"
                                                    )
                                                ).as(:oneline)
                                            )
                                        ),
                                        "rpf" arg,
                                        "scope" arg (
                                            c(
                                                "prefix" (
                                                  ipprefix
                                                ),
                                                "interface" (
                                                  interface_name
                                                )
                                            )
                                        ),
                                        "scope-policy" (
                                          policy_algebra
                                        ),
                                        "flow-map" arg (
                                            c(
                                                "policy" (
                                                  policy_algebra
                                                ),
                                                "bandwidth" (
                                                    c(
                                                        arg,
                                                        "adaptive"
                                                    )
                                                ).as(:oneline),
                                                "redundant-sources" (
                                                  ipaddr
                                                ),
                                                "forwarding-cache" (
                                                    c(
                                                        "timeout" (
                                                            c(
                                                                c(
                                                                    arg,
                                                                  "never" (
                                                                      c(
                                                                          "non-discard-entry-only"
                                                                      )
                                                                  )
                                                                )
                                                            )
                                                        ).as(:oneline)
                                                    )
                                                )
                                            )
                                        ),
                                        "resolve-filter" (
                                          policy_algebra
                                        ),
                                        "ssm-groups" (
                                          ipprefix
                                        ),
                                        "asm-override-ssm",
                                        "rpf-check-policy" (
                                          policy_algebra
                                        ),
                                        "pim-to-igmp-proxy" (
                                            c(
                                                "upstream-interface" (
                                                  interface_name
                                                )
                                            )
                                        ),
                                        "pim-to-mld-proxy" (
                                            c(
                                                "upstream-interface" (
                                                  interface_name
                                                )
                                            )
                                        ),
                                        "forwarding-cache" (
                                            c(
                                                "allow-maximum",
                                                "family" (("inet" | "inet6")) (
                                                    c(
                                                        "threshold" (
                                                            c(
                                                                "suppress" arg,
                                                                "reuse" arg,
                                                                "mvpn-rpt-suppress" arg,
                                                                "mvpn-rpt-reuse" arg,
                                                                "log-warning" arg
                                                            )
                                                        )
                                                    )
                                                ),
                                                "threshold" (
                                                    c(
                                                        "suppress" arg,
                                                        "reuse" arg,
                                                        "mvpn-rpt-suppress" arg,
                                                        "mvpn-rpt-reuse" arg,
                                                        "log-warning" arg
                                                    )
                                                ),
                                                "timeout" arg
                                            )
                                        ),
                                        "interface" (
                                          multicast_interface_options_type
                                        ),
                                        "ssm-map" arg (
                                            c(
                                                "policy" (
                                                  policy_algebra
                                                ),
                                                "source" (
                                                  ipaddr
                                                )
                                            )
                                        ),
                                        "stream-protection" (
                                            c(
                                                "mofrr-primary-path-selection-by-routing",
                                                "mofrr-disjoint-upstream-only",
                                                "mofrr-no-backup-join",
                                                "mofrr-asm-starg",
                                                "policy" (
                                                  policy_algebra
                                                )
                                            )
                                        ),
                                        "backup-pe-group" arg (
                                            c(
                                                "backups" (
                                                  ipaddr
                                                ),
                                                "local-address" (
                                                  ipaddr
                                                )
                                            )
                                        ),
                                        "omit-wildcard-address",
                                        "local-address" (
                                          ipv4addr
                                        )
                                    )
                                )
                            )
                        )
                    )
            )
        ),
        "interfaces" (
            c(
                "pic-set" arg (
                    c(
                        "interface" arg,
                        "fpc" arg (
                            c(
                                "pic" arg
                            )
                        )
                    )
                ),
                "interface-set" ("$junos-interface-set-name" | arg | "$junos-svlan-interface-set-name" | "$junos-tagged-vlan-interface-set-name" | "$junos-phy-ifd-interface-set-name" | "$junos-pon-id-interface-set-name") (
                    c(
                        "targeted-distribution",
                        "targeted-options",
                        "interface" arg (
                            c(
                                "unit" arg,
                                "vlan-tags-outer" arg
                            )
                        ),
                        "pppoe-underlying-options" (
                          pppoe_underlying_options_type
                        )
                    )
                ),
                "traceoptions" (
                    c(
                        "no-remote-trace",
                        "file" (
                            c(
                                  arg,
                                "size" arg,
                                "files" arg,
                                "world-readable",
                                "no-world-readable",
                                "match" (
                                  regular_expression
                                )
                            )
                        ).as(:oneline),
                        "flag" (("all" | "kernel" | "change-events" | "kernel-detail" | "config-states" | "resource-usage" | "gres-events" | "select-events" | "bfd-events" | "lib-events" | "reserved" | "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "informational" | "debugging" | "verbose" | "japi")) (
                            c(
                                "disable"
                            )
                        ).as(:oneline)
                    )
                ),
                "interface-range" arg (
                    c(
                        "member" arg,
                        "member-range" arg (
                            c(
                                "end-range" (
                                  interface_device
                                )
                            )
                        ).as(:oneline),
                        "description" arg,
                        "metadata" arg,
                          ("disable"),
                        "promiscuous-mode",
                        "port-mirror-instance" arg,
                        "multicast-statistics",
                        "oam-on-svlan",
                        "fabric-options" (
                            c(
                                "member-interfaces" arg
                            )
                        ),
                        "traceoptions" (
                            c(
                                "flag" (("ipc" | "event" | "media" | "all")).as(:oneline)
                            )
                        ),
                        "passive-monitor-mode",
                        c(
                          "keepalives" (
                            keepalives_type
                          ).as(:oneline),
                          "no-keepalives"
                        ),
                        "traps",
                        "no-traps",
                        "interface-mib",
                        "no-interface-mib",
                        "accounting-profile" arg,
                        "anchor-point" (
                            c(
                                  interface_device
                            )
                        ),
                        "bypass-queueing-chip",
                        "no-bypass-queueing-chip",
                        c(
                          "per-unit-scheduler",
                          "no-per-unit-scheduler",
                          "shared-scheduler",
                          "hierarchical-scheduler" (
                              c(
                                  "maximum-hierarchy-levels" arg,
                                  "implicit-hierarchy"
                              )
                          ).as(:oneline)
                        ),
                        "l2tp-maximum-session" arg,
                        "schedulers" arg,
                        "interface-transmit-statistics",
                        "cascade-port",
                        "dce",
                        c(
                          "vlan-tagging",
                          "stacked-vlan-tagging",
                          "flexible-vlan-tagging",
                          "vlan-vci-tagging"
                        ),
                        "native-vlan-id" arg,
                        "no-native-vlan-insert",
                        "speed" (
                          ("auto" | "auto-10m-100m" | "10m" | "100m" | "1g" | "10g" | "40g" | "oc3" | "oc12" | "oc48")
                        ),
                        "forwarding-class-accounting" (
                            c(
                                "direction" (
                                  ("ingress" | "egress" | "both")
                                ),
                                "enhanced" (
                                    c(
                                        "traffic-type" (
                                          ("unicast-statistics" | "multicast-statistics")
                                        ),
                                        "family" (
                                          ("inet" | "inet6" | "both")
                                        ),
                                        "direction" (
                                          ("ingress" | "egress" | "both")
                                        ),
                                        "overhead-bytes" arg
                                    )
                                )
                            )
                        ),
                        "auto-configure" (
                          auto_configure_vlan_type
                        ),
                        "mtu" arg,
                        "hold-time" (
                            c(
                                "up" arg,
                                "down" arg
                            )
                        ).as(:oneline),
                        "damping" (
                            c(
                                "half-life" arg,
                                "max-suppress" arg,
                                "reuse" arg,
                                "suppress" arg,
                                "enable"
                            )
                        ),
                        "link-degrade-monitor" (
                            c(
                                "actions" (
                                    c(
                                        c(
                                          "media-based"
                                        )
                                    )
                                ),
                                "recovery" (
                                    c(
                                        "timer" arg,
                                        c(
                                          "auto",
                                          "manual"
                                        )
                                    )
                                ),
                                "thresholds" (
                                    c(
                                        "set" arg,
                                        "clear" arg,
                                        "warning-set" arg,
                                        "warning-clear" arg,
                                        "interval" arg
                                    )
                                )
                            )
                        ),
                        "satop-options" (
                            c(
                                "idle-pattern" arg,
                                "payload-size" arg,
                                "excessive-packet-loss-rate" (
                                    c(
                                        "threshold" arg,
                                        "sample-period" arg
                                    )
                                ),
                                c(
                                  "jitter-buffer-packets" arg,
                                  "jitter-buffer-latency" arg,
                                  "jitter-buffer-auto-adjust"
                                ),
                                "bit-rate" arg
                            )
                        ),
                        "cesopsn-options" (
                            c(
                                "idle-pattern" arg,
                                "packetization-latency" arg,
                                "payload-size" arg,
                                "excessive-packet-loss-rate" (
                                    c(
                                        "threshold" arg,
                                        "sample-period" arg
                                    )
                                ),
                                c(
                                  "jitter-buffer-packets" arg,
                                  "jitter-buffer-latency" arg,
                                  "jitter-buffer-auto-adjust"
                                ),
                                "bit-rate" arg
                            )
                        ),
                        "ima-group-options" (
                            c(
                                "frame-length" (
                                  ("32" | "64" | "128" | "256")
                                ),
                                "symmetry" (
                                  ("symmetrical-config-and-operation" | "symmetrical-config-asymmetrical-operation")
                                ),
                                "transmit-clock" (
                                  ("common" | "independent")
                                ),
                                "version" (
                                  ("1.0" | "1.1")
                                ),
                                "minimum-links" (
                                    c(
                                        c(
                                            arg
                                        )
                                    )
                                ),
                                "frame-synchronization" (
                                    c(
                                        "alpha" arg,
                                        "beta" arg,
                                        "gamma" arg
                                    )
                                ),
                                "test-procedure" (
                                    c(
                                        "period" arg,
                                        "interface" (
                                          interface_device
                                        ),
                                        "pattern" arg
                                    )
                                ),
                                "differential-delay" arg
                            )
                        ),
                        "ima-link-options" (
                            c(
                                "group-id" arg
                            )
                        ),
                        "multi-chassis-protection" (
                          multi_chassis_protection_group
                        ),
                        "clocking" (
                            c(
                                c(
                                  "internal",
                                  "external"
                                )
                            )
                        ).as(:oneline),
                        "link-mode" (
                          ("automatic" | "half-duplex" | "full-duplex")
                        ),
                        "media-type" (
                          ("copper" | "fiber")
                        ),
                        "encapsulation" (
                          ("ethernet" | "fddi" | "token-ring" | "ppp" | "ppp-ccc" | "ppp-tcc" | "ether-vpls-ppp" | "frame-relay" | "frame-relay-ccc" | "frame-relay-tcc" | "extended-frame-relay-ccc" | "extended-frame-relay-tcc" | "flexible-frame-relay" | "frame-relay-port-ccc" | "frame-relay-ether-type" | "frame-relay-ether-type-tcc" | "extended-frame-relay-ether-type-tcc" | "cisco-hdlc" | "cisco-hdlc-ccc" | "cisco-hdlc-tcc" | "vlan-ccc" | "extended-vlan-ccc" | "ethernet-ccc" | "flexible-ethernet-services" | "smds-dxi" | "atm-pvc" | "atm-ccc-cell-relay" | "ethernet-over-atm" | "ethernet-tcc" | "extended-vlan-tcc" | "multilink-frame-relay-uni-nni" | "satop" | "cesopsn" | "ima" | "ethernet-vpls" | "ethernet-bridge" | "vlan-vpls" | "vlan-vci-ccc" | "extended-vlan-vpls" | "extended-vlan-bridge" | "multilink-ppp" | "generic-services")
                        ),
                        "esi" (
                            c(
                                  esi,
                                c(
                                  "single-active",
                                  "all-active"
                                ),
                                "source-bmac" (
                                  mac_unicast
                                )
                            )
                        ),
                        "framing" (
                            c(
                                c(
                                  "lan-phy",
                                  "wan-phy",
                                  "sonet",
                                  "sdh"
                                )
                            )
                        ),
                        "unidirectional",
                        "lmi" (
                            c(
                                "n391dte" arg,
                                "n392dce" arg,
                                "n392dte" arg,
                                "n393dce" arg,
                                "n393dte" arg,
                                "t391dte" arg,
                                "t392dce" arg,
                                "lmi-type" (
                                  ("ansi" | "itu" | "c-lmi")
                                )
                            )
                        ),
                        "mlfr-uni-nni-bundle-options" (
                            c(
                                "cisco-interoperability" (
                                    c(
                                        "send-lip-remove-link-for-link-reject"
                                    )
                                ),
                                "mrru" arg,
                                "yellow-differential-delay" arg,
                                "red-differential-delay" arg,
                                "action-red-differential-delay" (
                                  ("remove-link" | "disable-tx")
                                ),
                                "fragment-threshold" arg,
                                "drop-timeout" arg,
                                "link-layer-overhead" (
                                  unsigned_float
                                ),
                                "lmi-type" (
                                  ("ansi" | "itu" | "c-lmi")
                                ),
                                "minimum-links" arg,
                                "hello-timer" arg,
                                "acknowledge-timer" arg,
                                "acknowledge-retries" arg,
                                "n391" arg,
                                "n392" arg,
                                "n393" arg,
                                "t391" arg,
                                "t392" arg
                            )
                        ),
                        "mac" (
                          mac_unicast
                        ),
                        "receive-bucket" (
                          dcd_rx_bucket_config
                        ),
                        "transmit-bucket" (
                          dcd_tx_bucket_config
                        ),
                        "shared-interface",
                        "sonet-options" (
                          sonet_options_type
                        ),
                        "logical-tunnel-options" (
                            c(
                                "per-unit-mac-disable"
                            )
                        ),
                        "aggregated-sonet-options" (
                            c(
                                "minimum-links" arg,
                                "link-speed" (
                                  ("oc3" | "oc12" | "oc48" | "oc192" | "oc768" | "mixed")
                                ),
                                "minimum-bandwidth" arg
                            )
                        ),
                        "atm-options" (
                            c(
                                "pic-type" (
                                  ("atm-ce" | "atm2" | "atm1")
                                ),
                                "cell-bundle-size" arg,
                                "cell-bundle-timeout" arg,
                                "plp-to-clp",
                                "use-null-cw",
                                "promiscuous-mode" (
                                    c(
                                        "vpi" arg.as(:oneline)
                                    )
                                ),
                                "vpi" arg (
                                    c(
                                        "maximum-vcs" arg,
                                        "shaping" (
                                          dcd_shaping_config
                                        ),
                                        "oam-period" (
                                            c(
                                                c(
                                                    arg,
                                                  "disable".as(:oneline)
                                                )
                                            )
                                        ).as(:oneline),
                                        "oam-liveness" (
                                            c(
                                                "up-count" arg,
                                                "down-count" arg
                                            )
                                        )
                                    )
                                ),
                                "ilmi",
                                "linear-red-profiles" arg (
                                    c(
                                        "queue-depth" arg,
                                        "high-plp-threshold" arg,
                                        "low-plp-threshold" arg,
                                        "high-plp-max-threshold" arg,
                                        "low-plp-max-threshold" arg
                                    )
                                ).as(:oneline),
                                "scheduler-maps" arg (
                                    c(
                                        "vc-cos-mode" (
                                          ("strict" | "alternate")
                                        ),
                                        "forwarding-class" arg (
                                            c(
                                                "priority" (
                                                  ("low" | "high")
                                                ),
                                                "transmit-weight" (
                                                    c(
                                                        c(
                                                          "percent" arg,
                                                          "cells" arg
                                                        )
                                                    )
                                                ).as(:oneline),
                                                c(
                                                  "epd-threshold" (
                                                    epd_threshold_config
                                                  ).as(:oneline),
                                                  "linear-red-profile" arg
                                                )
                                            )
                                        )
                                    )
                                ),
                                "mpls" (
                                  mpls_ifd_options
                                ),
                                "payload-scrambler",
                                "no-payload-scrambler"
                            )
                        ),
                        "multiservice-options" (
                            c(
                                "syslog",
                                "no-syslog",
                                "core-dump",
                                "no-core-dump",
                                "dump-on-flow-control",
                                "no-dump-on-flow-control",
                                "reset-on-flow-control",
                                "no-reset-on-flow-control",
                                "flow-control-options" (
                                    c(
                                        "dump-on-flow-control",
                                        "reset-on-flow-control",
                                        "down-on-flow-control"
                                    )
                                )
                            )
                        ),
                        "ggsn-options" (
                            c(
                                "syslog",
                                "no-syslog",
                                "core-dump",
                                "no-core-dump"
                            )
                        ),
                        "ppp-options" (
                          ppp_options_type
                        ),
                        "redundancy-options" (
                            c(
                                "primary" (
                                  interface_device
                                ),
                                "secondary" (
                                  interface_device
                                ),
                                "redundancy-peer" (
                                    c(
                                        "ipaddress" (
                                          ipv4addr
                                        )
                                    )
                                ),
                                "redundancy-local" (
                                    c(
                                        "data-address" (
                                          ipv4addr
                                        )
                                    )
                                ),
                                "routing-instance" arg,
                                "replication-threshold" arg,
                                "replication-options" (
                                    c(
                                        "mtu" arg
                                    )
                                ),
                                "replicate-services" (
                                    c(
                                        "pgcp"
                                    )
                                )
                            )
                        ),
                        "load-balancing-options" (
                            c(
                                "member-interface" arg,
                                "member-failure-options" (
                                    c(
                                        c(
                                          "redistribute-all-traffic" (
                                              c(
                                                  "enable-rejoin"
                                              )
                                          ),
                                          "drop-member-traffic" (
                                              c(
                                                  "rejoin-timeout" arg,
                                                  "enable-rejoin"
                                              )
                                          )
                                        )
                                    )
                                ),
                                "high-availability-options" (
                                    c(
                                        c(
                                          "many-to-one" (
                                              c(
                                                  "preferred-backup" (
                                                    interface_device
                                                  )
                                              )
                                          ),
                                          "one-to-one" (
                                              c(
                                                  "preferred-backup" (
                                                    interface_device
                                                  )
                                              )
                                          )
                                        )
                                    )
                                )
                            )
                        ),
                        "aggregated-inline-services-options" (
                            c(
                                "primary-interface" (
                                  interface_device
                                ),
                                "secondary-interface" (
                                  interface_device
                                )
                            )
                        ),
                        "anchoring-options" (
                            c(
                                "apfe-group-set" arg,
                                "primary-list" arg,
                                "secondary" (
                                    c(
                                        arg
                                    )
                                ),
                                c(
                                  "warm-standby"
                                )
                            )
                        ),
                        "lsq-failure-options" (
                            c(
                                "trigger-link-failure" arg,
                                "no-termination-request",
                                "no-no-termination-request"
                            )
                        ),
                        "redundancy-group" (
                            c(
                                "member-interface" arg (
                                    c(
                                        c(
                                          "active",
                                          "backup"
                                        )
                                    )
                                ),
                                "maximum-links" arg
                            )
                        ),
                        "services-options" (
                            c(
                                "syslog" (
                                  service_set_syslog_object
                                ),
                                "jflow-log" (
                                    c(
                                        "message-rate-limit" arg
                                    )
                                ),
                                "open-timeout" arg,
                                "close-timeout" arg,
                                "inactivity-timeout" arg,
                                "inactivity-tcp-timeout" arg,
                                "inactivity-asymm-tcp-timeout" arg,
                                "inactivity-non-tcp-timeout" arg,
                                "session-timeout" arg,
                                "disable-global-timeout-override",
                                "tcp-tickles" arg,
                                "trio-flow-offload" (
                                    c(
                                        "minimum-bytes" arg
                                    )
                                ),
                                "fragment-limit" arg,
                                "reassembly-timeout" arg,
                                "cgn-pic",
                                "pba-interim-logging-interval" arg,
                                "session-limit" (
                                    c(
                                        "maximum" arg,
                                        "rate" arg,
                                        "cpu-load-threshold" arg
                                    )
                                ),
                                "ignore-errors" (
                                    c(
                                        "tcp",
                                        "alg"
                                    )
                                ).as(:oneline),
                                "capture" (
                                    c(
                                        "capture-size" arg,
                                        "pkt-size" arg,
                                        "logs-per-packet" arg,
                                        "max-log-line-size" arg,
                                        "filter" (
                                            c(
                                                "source-ip" (
                                                    c(
                                                          ipaddr,
                                                        "wildcard" (
                                                          ipaddr
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "dest-ip" (
                                                    c(
                                                          ipaddr,
                                                        "wildcard" (
                                                          ipaddr
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "sw-sip" (
                                                    c(
                                                          ipv6addr,
                                                        "wildcard" (
                                                          ipv6addr
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "sw-dip" (
                                                    c(
                                                          ipaddr,
                                                        "wildcard" (
                                                          ipaddr
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "sport-range" (
                                                    c(
                                                        "low" arg,
                                                        "high" arg
                                                    )
                                                ).as(:oneline),
                                                "dport-range" (
                                                    c(
                                                        "low" arg,
                                                        "high" arg
                                                    )
                                                ).as(:oneline),
                                                "proto" (
                                                  ("icmp" | "tcp" | "udp")
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        ),
                        "t3-options" (
                            c(
                                "loopback" (
                                  ("local" | "remote" | "payload")
                                ),
                                "long-buildout",
                                "no-long-buildout",
                                "loop-timing",
                                "no-loop-timing",
                                "unframed",
                                "no-unframed",
                                "compatibility-mode" (
                                    c(
                                        c(
                                          "larscom" (
                                              c(
                                                  "subrate" arg
                                              )
                                          ).as(:oneline),
                                          "verilink" (
                                              c(
                                                  "subrate" arg
                                              )
                                          ).as(:oneline),
                                          "adtran" (
                                              c(
                                                  "subrate" arg
                                              )
                                          ).as(:oneline),
                                          "kentrox" (
                                              c(
                                                  "subrate" arg
                                              )
                                          ).as(:oneline),
                                          "digital-link" (
                                              c(
                                                  "subrate" (
                                                    ("301Kb" | "601Kb" | "902Kb" | "1.2Mb" | "1.5Mb" | "1.8Mb" | "2.1Mb" | "2.4Mb" | "2.7Mb" | "3.0Mb" | "3.3Mb" | "3.6Mb" | "3.9Mb" | "4.2Mb" | "4.5Mb" | "4.8Mb" | "5.1Mb" | "5.4Mb" | "5.7Mb" | "6.0Mb" | "6.3Mb" | "6.6Mb" | "6.9Mb" | "7.2Mb" | "7.5Mb" | "7.8Mb" | "8.1Mb" | "8.4Mb" | "8.7Mb" | "9.0Mb" | "9.3Mb" | "9.6Mb" | "9.9Mb" | "10.2Mb" | "10.5Mb" | "10.8Mb" | "11.1Mb" | "11.4Mb" | "11.7Mb" | "12.0Mb" | "12.3Mb" | "12.6Mb" | "12.9Mb" | "13.2Mb" | "13.5Mb" | "13.8Mb" | "14.1Mb" | "14.4Mb" | "14.7Mb" | "15.0Mb" | "15.3Mb" | "15.6Mb" | "15.9Mb" | "16.2Mb" | "16.5Mb" | "16.8Mb" | "17.1Mb" | "17.4Mb" | "17.7Mb" | "18.0Mb" | "18.3Mb" | "18.6Mb" | "18.9Mb" | "19.2Mb" | "19.5Mb" | "19.8Mb" | "20.1Mb" | "20.5Mb" | "20.8Mb" | "21.1Mb" | "21.4Mb" | "21.7Mb" | "22.0Mb" | "22.3Mb" | "22.6Mb" | "22.9Mb" | "23.2Mb" | "23.5Mb" | "23.8Mb" | "24.1Mb" | "24.4Mb" | "24.7Mb" | "25.0Mb" | "25.3Mb" | "25.6Mb" | "25.9Mb" | "26.2Mb" | "26.5Mb" | "26.8Mb" | "27.1Mb" | "27.4Mb" | "27.7Mb" | "28.0Mb" | "28.3Mb" | "28.6Mb" | "28.9Mb" | "29.2Mb" | "29.5Mb" | "29.8Mb" | "30.1Mb" | "30.4Mb" | "30.7Mb" | "31.0Mb" | "31.3Mb" | "31.6Mb" | "31.9Mb" | "32.2Mb" | "32.5Mb" | "32.8Mb" | "33.1Mb" | "33.4Mb" | "33.7Mb" | "34.0Mb" | "34.3Mb" | "34.6Mb" | "34.9Mb" | "35.2Mb" | "35.5Mb" | "35.8Mb" | "36.1Mb" | "36.4Mb" | "36.7Mb" | "37.0Mb" | "37.3Mb" | "37.6Mb" | "37.9Mb" | "38.2Mb" | "38.5Mb" | "38.8Mb" | "39.1Mb" | "39.4Mb" | "39.7Mb" | "40.0Mb" | "40.3Mb" | "40.6Mb" | "40.9Mb" | "41.2Mb" | "41.5Mb" | "41.8Mb" | "42.1Mb" | "42.4Mb" | "42.7Mb" | "43.0Mb" | "43.3Mb" | "43.6Mb" | "43.9Mb" | "44.2Mb")
                                                  )
                                              )
                                          ).as(:oneline)
                                        )
                                    )
                                ).as(:oneline),
                                "payload-scrambler",
                                "no-payload-scrambler",
                                "cbit-parity",
                                "no-cbit-parity",
                                "fcs" (
                                  ("32" | "16")
                                ),
                                "idle-cycle-flag" (
                                  ("flags" | "ones")
                                ),
                                "start-end-flag" (
                                  ("shared" | "filler")
                                ),
                                "feac-loop-respond",
                                "no-feac-loop-respond",
                                "bert-algorithm" (
                                  ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                ),
                                "bert-error-rate" arg,
                                "bert-period" arg,
                                "buildout" arg,
                                "atm-encapsulation" (
                                  ("plcp" | "direct")
                                )
                            )
                        ),
                        "e3-options" (
                            c(
                                "loopback" (
                                  ("local" | "remote")
                                ),
                                "unframed",
                                "no-unframed",
                                "compatibility-mode" (
                                    c(
                                        c(
                                          "larscom",
                                          "digital-link" (
                                              c(
                                                  "subrate" (
                                                    ("358Kb" | "716Kb" | "1.1Mb" | "1.4Mb" | "1.8Mb" | "2.1Mb" | "2.5Mb" | "2.9Mb" | "3.2Mb" | "3.6Mb" | "3.9Mb" | "4.3Mb" | "4.7Mb" | "5.0Mb" | "5.4Mb" | "5.7Mb" | "6.1Mb" | "6.4Mb" | "6.8Mb" | "7.2Mb" | "7.5Mb" | "7.9Mb" | "8.2Mb" | "8.6Mb" | "9.0Mb" | "9.3Mb" | "9.7Mb" | "10.0Mb" | "10.4Mb" | "10.7Mb" | "11.1Mb" | "11.5Mb" | "11.8Mb" | "12.2Mb" | "12.5Mb" | "12.9Mb" | "13.2Mb" | "13.6Mb" | "14.0Mb" | "14.3Mb" | "14.7Mb" | "15.0Mb" | "15.4Mb" | "15.8Mb" | "16.1Mb" | "16.5Mb" | "16.8Mb" | "17.2Mb" | "17.5Mb" | "17.9Mb" | "18.3Mb" | "18.6Mb" | "19.0Mb" | "19.3Mb" | "19.7Mb" | "20.0Mb" | "20.4Mb" | "20.8Mb" | "21.1Mb" | "21.5Mb" | "21.8Mb" | "22.2Mb" | "22.6Mb" | "22.9Mb" | "23.3Mb" | "23.6Mb" | "24.0Mb" | "24.3Mb" | "24.7Mb" | "25.1Mb" | "25.4Mb" | "25.8Mb" | "26.1Mb" | "26.5Mb" | "26.9Mb" | "27.2Mb" | "27.6Mb" | "27.9Mb" | "28.3Mb" | "28.6Mb" | "29.0Mb" | "29.4Mb" | "29.7Mb" | "30.1Mb" | "30.4Mb" | "30.8Mb" | "31.1Mb" | "31.5Mb" | "31.9Mb" | "32.2Mb" | "32.6Mb" | "32.9Mb" | "33.3Mb" | "33.7Mb" | "34.0Mb")
                                                  )
                                              )
                                          ).as(:oneline),
                                          "kentrox" (
                                              c(
                                                  "subrate" arg
                                              )
                                          ).as(:oneline)
                                        )
                                    )
                                ).as(:oneline),
                                "payload-scrambler",
                                "no-payload-scrambler",
                                "fcs" (
                                  ("32" | "16")
                                ),
                                "idle-cycle-flag" (
                                  ("flags" | "ones")
                                ),
                                "invert-data",
                                "start-end-flag" (
                                  ("shared" | "filler")
                                ),
                                "bert-algorithm" (
                                  ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                ),
                                "bert-error-rate" arg,
                                "bert-period" arg,
                                "buildout" arg,
                                "atm-encapsulation" (
                                  ("plcp" | "direct")
                                ),
                                "framing" (
                                  ("g.751" | "g.832")
                                )
                            )
                        ),
                        "e1-options" (
                            c(
                                "timeslots" arg,
                                "loopback" (
                                  ("local" | "remote")
                                ),
                                "framing" (
                                  ("g704" | "unframed" | "g704-no-crc4")
                                ),
                                "fcs" (
                                  ("32" | "16")
                                ),
                                "invert-data",
                                "idle-cycle-flag" (
                                  ("flags" | "ones")
                                ),
                                "start-end-flag" (
                                  ("shared" | "filler")
                                ),
                                "bert-algorithm" (
                                  ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                ),
                                "bert-error-rate" arg,
                                "bert-period" arg
                            )
                        ),
                        "t1-options" (
                            c(
                                "timeslots" arg,
                                "voice-timeslots" arg,
                                "disable-remote-alarm-detection" (
                                  ("yellow")
                                ),
                                "loopback" (
                                  ("local" | "remote" | "payload")
                                ),
                                "buildout" (
                                  ("0-132" | "133-265" | "266-398" | "399-531" | "532-655" | "long-0db" | "long-7.5db" | "long-15db" | "long-22.5db")
                                ),
                                "byte-encoding" (
                                  ("nx64" | "nx56")
                                ),
                                "line-encoding" (
                                  ("ami" | "b8zs")
                                ),
                                "invert-data",
                                "framing" (
                                  ("sf" | "esf")
                                ),
                                "fcs" (
                                  ("32" | "16")
                                ),
                                "idle-cycle-flag" (
                                  ("flags" | "ones")
                                ),
                                "start-end-flag" (
                                  ("shared" | "filler")
                                ),
                                "bert-algorithm" (
                                  ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                ),
                                "bert-error-rate" arg,
                                "bert-period" arg,
                                "remote-loopback-respond",
                                "crc-major-alarm-threshold" (
                                  ("1e-3" | "5e-4" | "1e-4" | "5e-5" | "1e-5")
                                ),
                                "crc-minor-alarm-threshold" (
                                  ("1e-3" | "5e-4" | "1e-4" | "5e-5" | "1e-5" | "5e-6" | "1e-6")
                                ),
                                "alarm-compliance" (
                                  ("accunet-t1-5-service")
                                )
                            )
                        ),
                        "ds0-options" (
                            c(
                                "loopback" (
                                  ("payload")
                                ),
                                "byte-encoding" (
                                  ("nx64" | "nx56")
                                ),
                                "invert-data",
                                "fcs" (
                                  ("32" | "16")
                                ),
                                "idle-cycle-flag" (
                                  ("flags" | "ones")
                                ),
                                "start-end-flag" (
                                  ("shared" | "filler")
                                ),
                                "bert-algorithm" (
                                  ("pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4" | "repeating-1-in-16")
                                ),
                                "bert-error-rate" arg,
                                "bert-period" arg
                            )
                        ),
                        "serial-options" (
                            c(
                                "line-protocol" (
                                  ("eia530" | "v.35" | "x.21")
                                ),
                                c(
                                  "dte-options" (
                                      c(
                                          "ignore-all",
                                          "dtr" (
                                              c(
                                                  c(
                                                    "assert",
                                                    "de-assert",
                                                    "normal",
                                                    "auto-synchronize" (
                                                        c(
                                                            "duration" arg,
                                                            "interval" arg
                                                        )
                                                    )
                                                  )
                                              )
                                          ).as(:oneline),
                                          "control-signal" (
                                            ("assert" | "de-assert" | "normal")
                                          ),
                                          "rts" (
                                            ("assert" | "de-assert" | "normal")
                                          ),
                                          "dcd" (
                                            ("require" | "ignore" | "normal")
                                          ),
                                          "dsr" (
                                            ("require" | "ignore" | "normal")
                                          ),
                                          "cts" (
                                            ("require" | "ignore" | "normal")
                                          ),
                                          "indication" (
                                            ("require" | "ignore" | "normal")
                                          ),
                                          "tm" (
                                            ("require" | "ignore" | "normal")
                                          )
                                      )
                                  ),
                                  "dce-options" (
                                      c(
                                          "ignore-all",
                                          "dtr" (
                                            ("require" | "ignore" | "normal")
                                          ),
                                          "rts" (
                                            ("require" | "ignore" | "normal")
                                          ),
                                          "dcd" (
                                            ("assert" | "de-assert" | "normal")
                                          ),
                                          "dsr" (
                                            ("assert" | "de-assert" | "normal")
                                          ),
                                          "cts" (
                                            ("assert" | "de-assert" | "normal")
                                          ),
                                          "tm" (
                                            ("require" | "ignore" | "normal")
                                          ),
                                          "dce-loopback-override"
                                      )
                                  )
                                ),
                                "dtr-circuit" (
                                  ("balanced" | "unbalanced")
                                ),
                                "dtr-polarity" (
                                  ("positive" | "negative")
                                ),
                                "rts-polarity" (
                                  ("positive" | "negative")
                                ),
                                "control-polarity" (
                                  ("positive" | "negative")
                                ),
                                "dcd-polarity" (
                                  ("positive" | "negative")
                                ),
                                "dsr-polarity" (
                                  ("positive" | "negative")
                                ),
                                "cts-polarity" (
                                  ("positive" | "negative")
                                ),
                                "indication-polarity" (
                                  ("positive" | "negative")
                                ),
                                "tm-polarity" (
                                  ("positive" | "negative")
                                ),
                                "clocking-mode" (
                                  ("dce" | "internal" | "loop")
                                ),
                                "transmit-clock" (
                                  ("invert")
                                ),
                                "clock-rate" (
                                  ("2.048mhz" | "2.341mhz" | "2.731mhz" | "3.277mhz" | "4.096mhz" | "5.461mhz" | "8.192mhz" | "16.384mhz" | "1.2khz" | "2.4khz" | "9.6khz" | "19.2khz" | "38.4khz" | "56.0khz" | "64.0khz" | "72.0khz" | "125.0khz" | "148.0khz" | "250.0khz" | "500.0khz" | "800.0khz" | "1.0mhz" | "1.3mhz" | "2.0mhz" | "4.0mhz" | "8.0mhz")
                                ),
                                "loopback" (
                                  ("local" | "remote" | "dce-local" | "dce-remote")
                                ),
                                "encoding" (
                                  ("nrz" | "nrzi")
                                ),
                                "idle-cycle-flag" (
                                  ("flags" | "ones")
                                )
                            )
                        ),
                        "gratuitous-arp-reply",
                        "no-gratuitous-arp-reply",
                        "no-gratuitous-arp-request",
                        "no-no-gratuitous-arp-request",
                        "arp-l2-validate",
                        "ether-options" (
                            c(
                                "loopback",
                                "no-loopback",
                                "source-filtering",
                                "no-source-filtering",
                                "ethernet-switch-profile" (
                                    c(
                                        "tag-protocol-id" arg,
                                        "ethernet-policer-profile" (
                                            c(
                                                "input-priority-map" (
                                                  cos_policer_input_priority_map
                                                ),
                                                "output-priority-map" (
                                                  cos_policer_output_priority_map
                                                ),
                                                "policer" (
                                                  cos_policer
                                                )
                                            )
                                        ),
                                        "storm-control" (
                                            c(
                                                arg
                                            )
                                        ),
                                        "recovery-timeout" (
                                            c(
                                                  arg
                                            )
                                        ).as(:oneline),
                                        "mac-learn-enable",
                                        "no-mac-learn-enable"
                                    )
                                ),
                                "asynchronous-notification",
                                "source-address-filter" arg.as(:oneline),
                                "auto-negotiation",
                                "no-auto-negotiation",
                                "flow-control",
                                "no-flow-control",
                                "configured-flow-control" (
                                    c(
                                        "rx-buffers" (
                                          ("on" | "off")
                                        ),
                                        "tx-buffers" (
                                          ("on" | "off")
                                        )
                                    )
                                ),
                                "link-mode" (
                                  ("automatic" | "half-duplex" | "full-duplex")
                                ),
                                "mpls" (
                                  mpls_ifd_options
                                ),
                                "ignore-l3-incompletes",
                                "no-auto-mdix",
                                "speed" (
                                    c(
                                        c(
                                          "auto-negotiation" (
                                              c(
                                                  "auto-negotiate-10-100"
                                              )
                                          ).as(:oneline),
                                          "ethernet-10m",
                                          "ethernet-100m",
                                          "ethernet-1g",
                                          "ethernet-10g"
                                        )
                                    )
                                ),
                                "ieee-802.3ad" (
                                    c(
                                        "lacp" (
                                            c(
                                                "force-up",
                                                "port-priority" arg
                                            )
                                        ),
                                          interface_device,
                                        c(
                                          "primary",
                                          "backup"
                                        ),
                                        "link-protection-sub-group" (
                                            c(
                                                  arg
                                            )
                                        ),
                                        "port-priority" arg
                                    )
                                ),
                                "ieee-802-3az-eee",
                                "mdi-mode" (
                                  ("auto" | "force" | "mdi" | "mdix")
                                ),
                                "redundant-parent" (
                                    c(
                                          interface_device
                                    )
                                ),
                                "autostate-exclude"
                            )
                        ),
                        "fibrechannel-options" (
                            c(
                                "loopback",
                                "no-loopback",
                                "bb-sc-n" arg,
                                "speed" (
                                  ("auto-negotiation" | "1g" | "2g" | "4g" | "8g")
                                )
                            )
                        ),
                        "gigether-options" (
                            c(
                                "loopback",
                                "no-loopback",
                                "loopback-remote",
                                "flow-control",
                                "no-flow-control",
                                "source-filtering",
                                "no-source-filtering",
                                c(
                                  "no-auto-negotiation",
                                  "auto-negotiation" (
                                      c(
                                          "remote-fault" (
                                            ("local-interface-offline" | "local-interface-online")
                                          )
                                      )
                                  ).as(:oneline)
                                ),
                                "mac-mode" (
                                  ("sgmii" | "mac-mode-1000base-x")
                                ),
                                "asynchronous-notification",
                                "source-address-filter" arg.as(:oneline),
                                "pad-to-minimum-frame-size",
                                "redundant-parent" (
                                    c(
                                          interface_device
                                    )
                                ),
                                "ieee-802.3ad" (
                                    c(
                                        "lacp" (
                                            c(
                                                "port-priority" arg
                                            )
                                        ),
                                          interface_device,
                                        "link-index" arg,
                                        c(
                                          "primary",
                                          "backup"
                                        ),
                                        "distribution-list" arg
                                    )
                                ),
                                "ethernet-switch-profile" (
                                    c(
                                        "tag-protocol-id" arg,
                                        "ethernet-policer-profile" (
                                            c(
                                                "ieee802.1-priority-map" (
                                                    c(
                                                        "premium" arg
                                                    )
                                                ),
                                                "input-priority-map" (
                                                  cos_policer_input_priority_map
                                                ),
                                                "output-priority-map" (
                                                  cos_policer_output_priority_map
                                                ),
                                                "policer" (
                                                  cos_policer
                                                )
                                            )
                                        ),
                                        "accept-from" (
                                            c(
                                                "mac-address" (
                                                  mac_list
                                                )
                                            )
                                        ),
                                        "reject-the-rest",
                                        "no-reject-the-rest",
                                        "mac-learn-enable"
                                    )
                                ),
                                "mpls" (
                                  mpls_ifd_options
                                ),
                                "ignore-l3-incompletes",
                                "no-auto-mdix",
                                "ieee-802-3az-eee",
                                "mru" arg,
                                "fec" (
                                  ("none" | "fec91" | "fec74")
                                )
                            )
                        ),
                        "optics-options" (
                            c(
                                "wavelength" (
                                  ("1568.77" | "1568.36" | "1568.26" | "1568.16" | "1568.05" | "1567.95" | "1567.85" | "1567.75" | "1567.64" | "1567.54" | "1567.44" | "1567.34" | "1567.23" | "1567.13" | "1567.03" | "1566.93" | "1566.83" | "1566.72" | "1566.62" | "1566.52" | "1566.42" | "1566.31" | "1566.21" | "1566.11" | "1566.01" | "1565.90" | "1565.80" | "1565.70" | "1565.60" | "1565.50" | "1565.39" | "1565.29" | "1565.19" | "1565.09" | "1564.99" | "1564.88" | "1564.78" | "1564.68" | "1564.58" | "1564.47" | "1564.37" | "1564.27" | "1564.17" | "1564.07" | "1563.96" | "1563.86" | "1563.76" | "1563.66" | "1563.56" | "1563.45" | "1563.35" | "1563.25" | "1563.15" | "1563.05" | "1562.95" | "1562.84" | "1562.74" | "1562.64" | "1562.54" | "1562.44" | "1562.33" | "1562.23" | "1562.13" | "1562.03" | "1561.93" | "1561.83" | "1561.72" | "1561.62" | "1561.52" | "1561.42" | "1561.32" | "1561.22" | "1561.11" | "1561.01" | "1560.91" | "1560.81" | "1560.71" | "1560.61" | "1560.50" | "1560.40" | "1560.30" | "1560.20" | "1560.10" | "1560.00" | "1559.90" | "1559.79" | "1559.69" | "1559.59" | "1559.49" | "1559.39" | "1559.29" | "1559.19" | "1559.08" | "1558.98" | "1558.88" | "1558.78" | "1558.68" | "1558.58" | "1558.48" | "1558.38" | "1558.27" | "1558.17" | "1558.07" | "1557.97" | "1557.87" | "1557.77" | "1557.67" | "1557.57" | "1557.46" | "1557.36" | "1557.26" | "1557.16" | "1557.06" | "1556.96" | "1556.86" | "1556.76" | "1556.66" | "1556.55" | "1556.45" | "1556.35" | "1556.25" | "1556.15" | "1556.05" | "1555.95" | "1555.85" | "1555.75" | "1555.65" | "1555.55" | "1555.44" | "1555.34" | "1555.24" | "1555.14" | "1555.04" | "1554.94" | "1554.84" | "1554.74" | "1554.64" | "1554.54" | "1554.44" | "1554.34" | "1554.23" | "1554.13" | "1554.03" | "1553.93" | "1553.83" | "1553.73" | "1553.63" | "1553.53" | "1553.43" | "1553.33" | "1553.23" | "1553.13" | "1553.03" | "1552.93" | "1552.83" | "1552.73" | "1552.62" | "1552.52" | "1552.42" | "1552.32" | "1552.22" | "1552.12" | "1552.02" | "1551.92" | "1551.82" | "1551.72" | "1551.62" | "1551.52" | "1551.42" | "1551.32" | "1551.22" | "1551.12" | "1551.02" | "1550.92" | "1550.82" | "1550.72" | "1550.62" | "1550.52" | "1550.42" | "1550.32" | "1550.22" | "1550.12" | "1550.02" | "1549.92" | "1549.82" | "1549.72" | "1549.62" | "1549.52" | "1549.42" | "1549.32" | "1549.21" | "1549.11" | "1549.01" | "1548.91" | "1548.81" | "1548.71" | "1548.61" | "1548.51" | "1548.41" | "1548.31" | "1548.21" | "1548.11" | "1548.02" | "1547.92" | "1547.82" | "1547.72" | "1547.62" | "1547.52" | "1547.42" | "1547.32" | "1547.22" | "1547.12" | "1547.02" | "1546.92" | "1546.82" | "1546.72" | "1546.62" | "1546.52" | "1546.42" | "1546.32" | "1546.22" | "1546.12" | "1546.02" | "1545.92" | "1545.82" | "1545.72" | "1545.62" | "1545.52" | "1545.42" | "1545.32" | "1545.22" | "1545.12" | "1545.02" | "1544.92" | "1544.82" | "1544.72" | "1544.63" | "1544.53" | "1544.43" | "1544.33" | "1544.23" | "1544.13" | "1544.03" | "1543.93" | "1543.83" | "1543.73" | "1543.63" | "1543.53" | "1543.43" | "1543.33" | "1543.23" | "1543.13" | "1543.04" | "1542.94" | "1542.84" | "1542.74" | "1542.64" | "1542.54" | "1542.44" | "1542.34" | "1542.24" | "1542.14" | "1542.04" | "1541.94" | "1541.84" | "1541.75" | "1541.65" | "1541.55" | "1541.45" | "1541.35" | "1541.25" | "1541.15" | "1541.05" | "1540.95" | "1540.85" | "1540.76" | "1540.66" | "1540.56" | "1540.46" | "1540.36" | "1540.26" | "1540.16" | "1540.06" | "1539.96" | "1539.86" | "1539.77" | "1539.67" | "1539.57" | "1539.47" | "1539.37" | "1539.27" | "1539.17" | "1539.07" | "1538.98" | "1538.88" | "1538.78" | "1538.68" | "1538.58" | "1538.48" | "1538.38" | "1538.28" | "1538.19" | "1538.09" | "1537.99" | "1537.89" | "1537.79" | "1537.69" | "1537.59" | "1537.50" | "1537.40" | "1537.30" | "1537.20" | "1537.10" | "1537.00" | "1536.90" | "1536.81" | "1536.71" | "1536.61" | "1536.51" | "1536.41" | "1536.31" | "1536.22" | "1536.12" | "1536.02" | "1535.92" | "1535.82" | "1535.72" | "1535.63" | "1535.53" | "1535.43" | "1535.33" | "1535.23" | "1535.13" | "1535.04" | "1534.94" | "1534.84" | "1534.74" | "1534.64" | "1534.54" | "1534.45" | "1534.35" | "1534.25" | "1534.15" | "1534.05" | "1533.96" | "1533.86" | "1533.76" | "1533.66" | "1533.56" | "1533.47" | "1533.37" | "1533.27" | "1533.17" | "1533.07" | "1532.98" | "1532.88" | "1532.78" | "1532.68" | "1532.58" | "1532.49" | "1532.39" | "1532.29" | "1532.19" | "1532.09" | "1532.00" | "1531.90" | "1531.80" | "1531.70" | "1531.60" | "1531.51" | "1531.41" | "1531.31" | "1531.21" | "1531.12" | "1531.02" | "1530.92" | "1530.82" | "1530.72" | "1530.63" | "1530.53" | "1530.43" | "1530.33" | "1530.24" | "1530.14" | "1530.04" | "1529.94" | "1529.85" | "1529.75" | "1529.65" | "1529.55" | "1529.46" | "1529.36" | "1529.26" | "1529.16" | "1529.07" | "1528.97" | "1528.87" | "1528.77" | "1528.38")
                                ),
                                "tx-power" arg,
                                "loopback",
                                "los-warning-threshold" arg,
                                "los-alarm-threshold" arg,
                                "modulation-format" (
                                  ("16qam" | "8qam" | "qpsk")
                                ),
                                "laser-enable",
                                "no-laser-enable",
                                "is-ma",
                                "no-is-ma",
                                "encoding" (
                                  ("differential" | "non-differential")
                                ),
                                "fec" (
                                  ("sdfec" | "sdfec25")
                                ),
                                "alarm" (("low-light-alarm")) (
                                    c(
                                        c(
                                          "syslog",
                                          "link-down"
                                        )
                                    )
                                ),
                                "tca" (
                                    c(
                                        "tx-power-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "tx-power-low-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "rx-power-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "rx-power-low-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "temperature-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "temperature-low-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "carrier-frequency-offset-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "carrier-frequency-offset-low-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "fec-ber" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ).as(:oneline),
                                        "tec-current-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "tec-current-low-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "residual-isi-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "residual-isi-low-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "pam-histogram-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "snr-low-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "fec-corrected-errors-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "fec-ucorrected-words-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "laser-frequency-error-high-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        ),
                                        "laser-frequency-error-low-tca" (
                                            c(
                                                "enable-tca",
                                                "no-enable-tca",
                                                "threshold" arg,
                                                "threshold-24hrs" arg
                                            )
                                        )
                                    )
                                ),
                                "warning" (("low-light-warning")) (
                                    c(
                                        c(
                                          "syslog",
                                          "link-down"
                                        )
                                    )
                                )
                            )
                        ),
                        "otn-options" (
                          otn_options_type
                        ),
                        "fastether-options" (
                            c(
                                "loopback",
                                "no-loopback",
                                "flow-control",
                                "no-flow-control",
                                "source-filtering",
                                "no-source-filtering",
                                "auto-negotiation",
                                "no-auto-negotiation",
                                "ingress-rate-limit" arg,
                                "source-address-filter" arg.as(:oneline),
                                "redundant-parent" (
                                    c(
                                          interface_device
                                    )
                                ),
                                "ieee-802.3ad" (
                                    c(
                                        "lacp" (
                                            c(
                                                "port-priority" arg
                                            )
                                        ),
                                          interface_device,
                                        c(
                                          "primary",
                                          "backup"
                                        )
                                    )
                                ),
                                "mpls" (
                                  mpls_ifd_options
                                ),
                                "ignore-l3-incompletes"
                            )
                        ),
                        "redundant-ether-options" (
                            c(
                                "redundancy-group" arg,
                                "loopback",
                                "no-loopback",
                                "flow-control",
                                "no-flow-control",
                                "source-filtering",
                                "no-source-filtering",
                                "source-address-filter" arg.as(:oneline),
                                "link-speed" (
                                  ("10m" | "100m" | "1g" | "10g")
                                ),
                                "minimum-links" arg,
                                "lacp" (
                                    c(
                                        c(
                                          "active",
                                          "passive"
                                        ),
                                        "periodic" (
                                          ("fast" | "slow")
                                        )
                                    )
                                )
                            )
                        ),
                        "aggregated-ether-options" (
                            c(
                                "loopback",
                                "no-loopback",
                                "flow-control",
                                "no-flow-control",
                                "source-filtering",
                                "no-source-filtering",
                                "autostate-exclude",
                                "link-protection" (
                                    c(
                                        "revertive",
                                        "backup-state" (
                                          ("accept-data" | "discard-data" | "down")
                                        )
                                    )
                                ),
                                "fcoe-lag",
                                "no-fcoe-lag",
                                "source-address-filter" arg.as(:oneline),
                                "configured-flow-control" (
                                    c(
                                        "rx-buffers" (
                                          ("on" | "off")
                                        ),
                                        "tx-buffers" (
                                          ("on" | "off")
                                        )
                                    )
                                ),
                                "load-balance" (
                                  aggregate_load_balance
                                ),
                                "bfd-liveness-detection" (
                                    c(
                                        "version" (
                                          ("0" | "1" | "automatic")
                                        ),
                                        "minimum-interval" arg,
                                        "minimum-transmit-interval" arg,
                                        "minimum-receive-interval" arg,
                                        "multiplier" arg,
                                        c(
                                          "no-adaptation"
                                        ),
                                        "transmit-interval" (
                                            c(
                                                "minimum-interval" arg,
                                                "threshold" arg
                                            )
                                        ),
                                        "detection-time" (
                                            c(
                                                "threshold" arg
                                            )
                                        ),
                                        "authentication" (
                                            c(
                                                "key-chain" arg,
                                                "algorithm" (
                                                  ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                                ),
                                                "loose-check"
                                            )
                                        ),
                                        "neighbor" (
                                          ipaddr
                                        ),
                                        "local-address" (
                                          ipaddr
                                        ),
                                        "holddown-interval" arg
                                    )
                                ),
                                "minimum-links" arg,
                                "minimum-bandwidth" (
                                    c(
                                        "bw-value" arg,
                                        "bw-unit" (
                                          ("bps" | "kbps" | "mbps" | "gbps")
                                        )
                                    )
                                ),
                                "targeted-options" (
                                    c(
                                        "type" (
                                          ("auto" | "manual")
                                        ),
                                        c(
                                          "logical-interface-fpc-redundancy",
                                          "logical-interface-chassis-redundancy"
                                        ),
                                        "rebalance-periodic" (
                                            c(
                                                "start-time" (
                                                  time
                                                ),
                                                "interval" arg
                                            )
                                        ),
                                        "rebalance-subscriber-granularity" arg
                                    )
                                ),
                                c(
                                  "logical-interface-fpc-redundancy",
                                  "logical-interface-chassis-redundancy"
                                ),
                                "rebalance-periodic" (
                                    c(
                                        "start-time" (
                                          time
                                        ),
                                        "interval" arg
                                    )
                                ),
                                "pad-to-minimum-frame-size",
                                "link-speed" (
                                  ("10m" | "100m" | "1g" | "8g" | "10g" | "25g" | "40g" | "50g" | "80g" | "100g" | "oc192" | "mixed")
                                ),
                                "local-bias" (
                                    c(
                                        "disable"
                                    )
                                ),
                                "local-minimum-links-threshold" arg,
                                "resilient-hash",
                                "lacp" (
                                    c(
                                        c(
                                          "active",
                                          "passive"
                                        ),
                                        "periodic" (
                                          ("fast" | "slow")
                                        ),
                                        "fast-failover",
                                        "link-protection" (
                                            c(
                                                "disable",
                                                c(
                                                  "revertive",
                                                  "non-revertive"
                                                )
                                            )
                                        ),
                                        "accept-data",
                                        "sync-reset" (
                                          ("disable" | "enable")
                                        ),
                                        "system-priority" arg,
                                        "system-id" (
                                          mac_addr
                                        ),
                                        "admin-key" arg,
                                        "hold-time" (
                                            c(
                                                "up" arg
                                            )
                                        ).as(:oneline),
                                        "aggregate-wait-time" arg,
                                        "force-up"
                                    )
                                ),
                                "link-protection-sub-group" arg (
                                    c(
                                        c(
                                          "primary",
                                          "backup"
                                        )
                                    )
                                ),
                                "ethernet-switch-profile" (
                                    c(
                                        "tag-protocol-id" arg,
                                        "storm-control" (
                                            c(
                                                arg
                                            )
                                        ),
                                        "mac-learn-enable"
                                    )
                                ),
                                "mc-ae" (
                                    c(
                                        "mc-ae-id" arg,
                                        "redundancy-group" arg,
                                        "chassis-id" arg,
                                        "mode" (
                                          ("active-standby" | "active-active")
                                        ),
                                        "status-control" (
                                          ("active" | "standby")
                                        ),
                                        "switchover-mode" (
                                          ("revertive" | "non-revertive")
                                        ),
                                        "revert-time" arg,
                                        "init-delay-time" arg,
                                        "recovery-delay-time" arg,
                                        "enhanced-convergence",
                                        "events" (
                                            c(
                                                "iccp-peer-down" (
                                                    c(
                                                        "force-icl-down",
                                                        "prefer-status-control-active"
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        ),
                        "es-options" (
                            c(
                                "backup-interface" (
                                  interface_device
                                )
                            )
                        ),
                        "dsl-options" (
                            c(
                                "operating-mode" (
                                  ("auto" | "ansi-dmt" | "itu-dmt" | "etsi" | "itu-annexb-ur2" | "itu-annexb-non-ur2" | "itu-dmt-bis" | "adsl2plus" | "annexm-itu-dmt-bis" | "annexm-adsl2plus")
                                )
                            )
                        ),
                        "vdsl-options" (
                            c(
                                "vdsl-profile" (
                                  ("auto" | "8a" | "8b" | "8c" | "8d" | "12a" | "12b" | "17a")
                                ),
                                "sra" (
                                  ("enable" | "disable")
                                ),
                                "v43" (
                                  ("enable" | "disable")
                                )
                            )
                        ),
                        "shdsl-options" (
                            c(
                                "annex" (
                                  ("annex-a" | "annex-b" | "annex-f" | "annex-g" | "annex-auto")
                                ),
                                "line-rate" (
                                  ("auto" | arg)
                                ),
                                "loopback" (
                                  ("local" | "remote")
                                ),
                                "snr-margin" (
                                    c(
                                        "current" (
                                          ("disable" | arg)
                                        ),
                                        "snext" (
                                          ("disable" | arg)
                                        )
                                    )
                                )
                            )
                        ),
                        "data-input" (
                            c(
                                c(
                                  "system",
                                  "interface" (
                                    interface_device
                                  )
                                )
                            )
                        ),
                        "switch-options" (
                            c(
                                "switch-port" arg (
                                    c(
                                        "auto-negotiation",
                                        "no-auto-negotiation",
                                        "link-mode" (
                                          ("half-duplex" | "full-duplex")
                                        ),
                                        "speed" (
                                          ("10m" | "100m" | "1g")
                                        ),
                                        "vlan-id" arg,
                                        "cascade-port"
                                    )
                                )
                            )
                        ),
                        "container-options" (
                            c(
                                "container-type" (
                                    c(
                                        c(
                                          "aps" (
                                            aps_type
                                          )
                                        )
                                    )
                                ),
                                "member-interface-type" (
                                    c(
                                        c(
                                          "sonet" (
                                              c(
                                                  "member-interface-speed" (
                                                    ("oc3" | "oc12" | "oc48" | "oc192" | "oc768" | "mixed")
                                                  )
                                              )
                                          ),
                                          "atm" (
                                              c(
                                                  "member-interface-speed" (
                                                    ("oc3" | "oc12" | "oc48")
                                                  )
                                              )
                                          ),
                                          "channelized-sonet" (
                                              c(
                                                  "member-interface-speed" (
                                                    ("coc3" | "coc12" | "coc48" | "coc192" | "coc768")
                                                  )
                                              )
                                          ),
                                          "channelized-sdh" (
                                              c(
                                                  "member-interface-speed" (
                                                    ("cstm1" | "cstm4" | "cstm16" | "coc64" | "cstm256")
                                                  )
                                              )
                                          )
                                        )
                                    )
                                ),
                                "redundancy" (
                                    c(
                                        "hold-time" (
                                            c(
                                                "up" arg,
                                                "down" arg
                                            )
                                        ).as(:oneline)
                                    )
                                ),
                                "container-list" (
                                  interface_device
                                ),
                                c(
                                    "primary",
                                    "standby"
                                ),
                                "fast-aps",
                                "allow-configuration-override"
                            )
                        ),
                        "layer2-policer" (
                            c(
                                c(
                                  "input-policer" arg,
                                  "input-hierarchical-policer" arg
                                )
                            )
                        ),
                        "unit" (("$junos-underlying-interface-unit" | "$junos-interface-unit" | arg)) (
                            c(
                                "policer-overhead" (
                                    c(
                                          arg,
                                        "ingress" arg,
                                        "egress" arg
                                    )
                                ),
                                "alias" arg,
                                "enhanced-convergence",
                                "proxy-macip-advertisement",
                                "peer-psd" (
                                    c(
                                        arg
                                    )
                                ).as(:oneline),
                                "peer-interface" (
                                    c(
                                          interface_unit
                                    )
                                ),
                                "interface-shared-with" (
                                    c(
                                        arg
                                    )
                                ),
                                  ("disable"),
                                "passive-monitor-mode",
                                "per-session-scheduler",
                                "account-layer2-overhead" (
                                    c(
                                          arg,
                                        "ingress" arg,
                                        "egress" arg
                                    )
                                ),
                                "forwarding-class-accounting" (
                                    c(
                                        "direction" (
                                          ("ingress" | "egress" | "both")
                                        ),
                                        "enhanced" (
                                            c(
                                                "traffic-type" (
                                                  ("unicast-statistics" | "multicast-statistics")
                                                ),
                                                "family" (
                                                  ("inet" | "inet6" | "both")
                                                ),
                                                "direction" (
                                                  ("ingress" | "egress" | "both")
                                                ),
                                                "overhead-bytes" arg
                                            )
                                        )
                                    )
                                ),
                                "clear-dont-fragment-bit",
                                "packet-inject-enable",
                                "reassemble-packets",
                                "services-options",
                                "rpm" (
                                    c(
                                        c(
                                          c(
                                            "client",
                                            "server"
                                          ),
                                          "twamp-server",
                                          "twamp-client"
                                        )
                                    )
                                ),
                                "description" arg,
                                "metadata" arg,
                                "dial-options" (
                                    c(
                                        c(
                                          "l2tp-interface-id" arg,
                                          "ipsec-interface-id" arg
                                        ),
                                        c(
                                          "dedicated",
                                          "shared"
                                        )
                                    )
                                ),
                                "actual-transit-statistics",
                                "demux-source" (
                                      (("inet" | "inet6"))
                                ),
                                "demux-destination" (
                                      (("inet" | "inet6"))
                                ),
                                "encapsulation" (
                                  ("atm-nlpid" | "atm-cisco-nlpid" | "atm-snap" | "atm-vc-mux" | "atm-ccc-vc-mux" | "atm-tcc-vc-mux" | "atm-tcc-snap" | "atm-ccc-cell-relay" | "vlan-vci-ccc" | "ether-over-atm-llc" | "ether-vpls-over-atm-llc" | "ppp-over-ether-over-atm-llc" | "ppp-over-ether" | "atm-ppp-vc-mux" | "atm-ppp-llc" | "atm-mlppp-llc" | "frame-relay-ppp" | "frame-relay-ccc" | "frame-relay" | "frame-relay-tcc" | "frame-relay-ether-type" | "frame-relay-ether-type-tcc" | "ether-vpls-fr" | "vlan-ccc" | "ethernet-ccc" | "vlan-vpls" | "vlan-bridge" | "dix" | "ethernet" | "ethernet-vpls" | "ethernet-bridge" | "vlan" | "vlan-tcc" | "multilink-ppp" | "multilink-frame-relay-end-to-end" | "ppp-ccc")
                                ),
                                "gre",
                                "mtu" arg,
                                c(
                                  "point-to-point",
                                  "multipoint"
                                ),
                                "bandwidth" arg,
                                "global-layer2-domainid" arg,
                                "radio-router" (
                                  dynamic_ifbw_parms_type
                                ),
                                "traps",
                                "no-traps",
                                "routing-services",
                                "no-routing-services",
                                "arp-resp" (
                                    c(
                                        c(
                                          "unrestricted",
                                          "restricted"
                                        )
                                    )
                                ).as(:oneline),
                                "proxy-arp" (
                                    c(
                                        c(
                                          "unrestricted",
                                          "restricted"
                                        )
                                    )
                                ).as(:oneline),
                                c(
                                  "vlan-id" (
                                    ("none" | arg)
                                  ),
                                  "vlan-id-range" arg,
                                  "inner-vlan-id-swap-ranges" arg,
                                  "vlan-id-list" arg,
                                  "vlan-tag" arg,
                                  "vlan-tags" (
                                      c(
                                          "outer" (
                                            ("$junos-stacked-vlan-id" | "$junos-vlan-id" | arg)
                                          ),
                                          c(
                                            "inner" (
                                              ("$junos-vlan-id" | arg)
                                            ),
                                            "inner-range" arg,
                                            "inner-list" arg
                                          )
                                      )
                                  ).as(:oneline)
                                ),
                                "native-inner-vlan-id" arg,
                                "inner-vlan-id-range" (
                                    c(
                                        "start" arg,
                                        "end" arg
                                    )
                                ).as(:oneline),
                                "accept-source-mac" (
                                    c(
                                        "mac-address" (
                                          mac_list
                                        )
                                    )
                                ),
                                "input-vlan-map" (
                                  vlan_map
                                ),
                                "output-vlan-map" (
                                  vlan_map
                                ),
                                "swap-by-poppush",
                                "receive-lsp" arg,
                                "transmit-lsp" arg,
                                "dlci" arg,
                                "multicast-dlci" arg,
                                c(
                                  "vci" (
                                    atm_vci
                                  ),
                                  "allow-any-vci",
                                  "vpi" arg,
                                  "trunk-id" arg
                                ),
                                "no-vpivci-swapping",
                                c(
                                  "psn-vci" (
                                    atm_vci
                                  ),
                                  "psn-vpi" arg
                                ),
                                "atm-l2circuit-mode" (
                                    c(
                                        c(
                                          "cell",
                                          "aal5"
                                        )
                                    )
                                ).as(:oneline),
                                "vci-range" (
                                    c(
                                        "start" arg,
                                        "end" arg
                                    )
                                ).as(:oneline),
                                "trunk-bandwidth" arg,
                                "multicast-vci" (
                                  atm_vci
                                ),
                                "shaping" (
                                  dcd_shaping_config
                                ),
                                "oam-period" (
                                    c(
                                        c(
                                            arg,
                                          "disable".as(:oneline)
                                        )
                                    )
                                ).as(:oneline),
                                "oam-liveness" (
                                    c(
                                        "up-count" arg,
                                        "down-count" arg
                                    )
                                ),
                                "ppp-options" (
                                  ppp_options_type
                                ),
                                "pppoe-options" (
                                  pppoe_options_type
                                ),
                                "pppoe-underlying-options" (
                                  pppoe_underlying_options_type
                                ),
                                "advisory-options" (
                                  advisory_options_type
                                ),
                                "auto-configure" (
                                  auto_configure_vlan_type
                                ),
                                "demux-options" (
                                  demux_options_type
                                ),
                                "targeted-distribution" (
                                    c(
                                        "primary-list" arg,
                                        "backup-list" arg,
                                        "standby-list" arg
                                    )
                                ),
                                "targeted-options" (
                                    c(
                                        "primary" (
                                          interface_device
                                        ),
                                        "backup" (
                                          interface_device
                                        ),
                                        "group" arg
                                    )
                                ),
                                c(
                                  "keepalives" (
                                    keepalives_type
                                  ).as(:oneline),
                                  "no-keepalives"
                                ),
                                "inverse-arp",
                                "transmit-weight" arg,
                                "epd-threshold" (
                                  epd_threshold_config
                                ).as(:oneline),
                                "cell-bundle-size" arg,
                                "cell-bundle-timeout" arg,
                                "plp-to-clp",
                                "atm-scheduler-map" arg,
                                "mrru" arg,
                                "short-sequence",
                                "fragment-threshold" arg,
                                "drop-timeout" arg,
                                "disable-mlppp-inner-ppp-pfc",
                                "minimum-links" arg,
                                "multilink-max-classes" arg,
                                "compression" (
                                    c(
                                        "rtp" (
                                            c(
                                                "f-max-period" arg,
                                                "queues" (
                                                  ("q0" | "q1" | "q2" | "q3")
                                                ),
                                                "port" (
                                                    c(
                                                        "minimum" arg,
                                                        "maximum" arg
                                                    )
                                                ).as(:oneline),
                                                "maximum-contexts" (
                                                    c(
                                                          arg
                                                    )
                                                ).as(:oneline)
                                            )
                                        )
                                    )
                                ),
                                "interleave-fragments",
                                "link-layer-overhead" (
                                  unsigned_float
                                ),
                                "accounting-profile" arg,
                                "peer-unit" arg,
                                "tunnel" (
                                    c(
                                        "source" (
                                          ipaddr
                                        ),
                                        "destination" (
                                          ipaddr
                                        ),
                                        "key" arg,
                                        "backup-destination" (
                                          ipaddr
                                        ),
                                        c(
                                          "allow-fragmentation",
                                          "do-not-fragment"
                                        ),
                                        "ttl" arg,
                                        "traffic-class" arg,
                                        "flow-label" arg,
                                        "path-mtu-discovery",
                                        "no-path-mtu-discovery",
                                        "routing-instance" (
                                            c(
                                                "destination" arg
                                            )
                                        )
                                    )
                                ),
                                "compression-device" (
                                  interface_unit
                                ),
                                "atm-policer" (
                                    c(
                                        "input-atm-policer" arg
                                    )
                                ),
                                "layer2-policer" (
                                    c(
                                        c(
                                          "input-policer" arg,
                                          "input-hierarchical-policer" arg,
                                          "input-three-color" arg
                                        ),
                                        c(
                                          "output-policer" (
                                            ("$junos-layer2-output-policer" | arg)
                                          ),
                                          "output-three-color" (
                                            ("$junos-layer2-output-policer" | arg)
                                          )
                                        )
                                    )
                                ),
                                "filter" (
                                    c(
                                        c(
                                          "input" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline)
                                        ),
                                        c(
                                          "output" (
                                              c(
                                                  arg,
                                                  "shared-name" arg,
                                                  "precedence" arg
                                              )
                                          ).as(:oneline)
                                        )
                                    )
                                ),
                                "multi-chassis-protection" (
                                  multi_chassis_protection_group_ifl
                                ),
                                "statistics",
                                "esi" (
                                    c(
                                          esi,
                                        c(
                                          "single-active",
                                          "all-active"
                                        )
                                    )
                                ),
                                "virtual-gateway-esi" (
                                    c(
                                          esi,
                                        c(
                                          "single-active",
                                          "all-active"
                                        )
                                    )
                                ),
                                "service" (
                                    c(
                                        "pcef" arg (
                                            c(
                                                "activate-all",
                                                "activate" arg
                                            )
                                        )
                                    )
                                ),
                                "family" (
                                    c(
                                        "inet" (
                                            c(
                                                "dhcp" (
                                                  dhcp_client_type
                                                ),
                                                "targeted-broadcast" (
                                                    c(
                                                        c(
                                                          "forward-and-send-to-re",
                                                          "forward-only"
                                                        )
                                                    )
                                                ),
                                                "destination-class-usage",
                                                "transit-options-packets",
                                                "transit-ttl-exceeded",
                                                "receive-options-packets",
                                                "receive-ttl-exceeded",
                                                "accounting" (
                                                    c(
                                                        "source-class-usage" (
                                                            c(
                                                                "input",
                                                                "output"
                                                            )
                                                        ),
                                                        "destination-class-usage"
                                                    )
                                                ),
                                                "mac-validate" (
                                                  ("strict" | "loose")
                                                ),
                                                "rpf-check" (
                                                    c(
                                                        "fail-filter" arg,
                                                        "mode" (
                                                            c(
                                                                "loose"
                                                            )
                                                        ).as(:oneline)
                                                    )
                                                ),
                                                "mtu" arg,
                                                "arp-max-cache" arg,
                                                "arp-new-hold-limit" arg,
                                                "tcp-mss" arg,
                                                "no-redirects",
                                                "no-neighbor-learn",
                                                "unconditional-src-learn",
                                                "multicast-only",
                                                "primary",
                                                "ipsec-sa" arg,
                                                "allow-filter-on-re",
                                                "demux-source" ("$junos-subscriber-ip-address" | arg),
                                                "demux-destination" ("$junos-subscriber-ip-address" | arg),
                                                "filter" (
                                                    c(
                                                        c(
                                                          "input" (
                                                              c(
                                                                  arg,
                                                                  "shared-name" arg,
                                                                  "precedence" arg
                                                              )
                                                          ).as(:oneline),
                                                          "input-list" arg
                                                        ),
                                                        c(
                                                          "output" (
                                                              c(
                                                                  arg,
                                                                  "shared-name" arg,
                                                                  "precedence" arg
                                                              )
                                                          ).as(:oneline),
                                                          "output-list" arg
                                                        ),
                                                        "adf" (
                                                            c(
                                                                "rule" arg,
                                                                "counter",
                                                                "input-precedence" arg,
                                                                "not-mandatory",
                                                                "output-precedence" arg
                                                            )
                                                        ),
                                                        "group" arg
                                                    )
                                                ),
                                                "ingress-queuing-filter" (
                                                    c(
                                                        arg
                                                    )
                                                ).as(:oneline),
                                                "simple-filter" (
                                                    c(
                                                        "input" arg
                                                    )
                                                ),
                                                "input-hierarchical-policer" arg,
                                                "policer" (
                                                    c(
                                                        "arp" arg,
                                                        "input" arg,
                                                        "output" arg
                                                    )
                                                ),
                                                "sampling" (
                                                    c(
                                                        "input",
                                                        "output"
                                                    )
                                                ),
                                                "service" (
                                                    c(
                                                        "input" (
                                                            c(
                                                                "service-set" arg (
                                                                    c(
                                                                        "service-filter" arg
                                                                    )
                                                                ),
                                                                "post-service-filter" arg
                                                            )
                                                        ),
                                                        "output" (
                                                            c(
                                                                "service-set" arg (
                                                                    c(
                                                                        "service-filter" arg
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                ),
                                                "next-hop-tunnel" arg (
                                                    c(
                                                        "ipsec-vpn" arg
                                                    )
                                                ),
                                                "address" arg (
                                                    c(
                                                        "destination" (
                                                          ipv4addr
                                                        ),
                                                        "destination-profile" arg,
                                                        "broadcast" (
                                                          ipv4addr
                                                        ),
                                                        "primary",
                                                        "preferred",
                                                        "master-only",
                                                        "multipoint-destination" arg (
                                                            c(
                                                                c(
                                                                  "dlci" arg,
                                                                  "vci" (
                                                                    atm_vci
                                                                  )
                                                                ),
                                                                "shaping" (
                                                                  dcd_shaping_config
                                                                ),
                                                                "oam-period" (
                                                                    c(
                                                                        c(
                                                                            arg,
                                                                          "disable".as(:oneline)
                                                                        )
                                                                    )
                                                                ).as(:oneline),
                                                                "oam-liveness" (
                                                                    c(
                                                                        "up-count" arg,
                                                                        "down-count" arg
                                                                    )
                                                                ),
                                                                "inverse-arp",
                                                                "transmit-weight" arg,
                                                                "epd-threshold" (
                                                                  epd_threshold_config
                                                                ).as(:oneline)
                                                            )
                                                        ),
                                                        "arp" arg (
                                                            c(
                                                                "l2-interface" (
                                                                  interface_name
                                                                ),
                                                                c(
                                                                  "mac" (
                                                                    mac_unicast
                                                                  ),
                                                                  "multicast-mac" (
                                                                    mac_multicast
                                                                  )
                                                                ),
                                                                "publish"
                                                            )
                                                        ).as(:oneline),
                                                        "web-authentication" (
                                                            c(
                                                                "http",
                                                                "https",
                                                                "redirect-to-https"
                                                            )
                                                        ),
                                                        "vrrp-group" (
                                                          vrrp_group
                                                        ),
                                                        "virtual-gateway-address" (
                                                          ipv4addr
                                                        )
                                                    )
                                                ),
                                                "unnumbered-address" (
                                                    c(
                                                          interface_unit,
                                                        "preferred-source-address" (
                                                          ("$junos-preferred-source-address" | arg)
                                                        ),
                                                        "destination" (
                                                          ipv4addr
                                                        ),
                                                        "destination-profile" arg
                                                    )
                                                ).as(:oneline),
                                                "location-pool-address" (
                                                    c(
                                                          arg
                                                    )
                                                ),
                                                "negotiate-address"
                                            )
                                        ),
                                        "iso" (
                                            c(
                                                "address" arg,
                                                "mtu" arg
                                            )
                                        ),
                                        "inet6" (
                                            c(
                                                "dhcpv6-client" (
                                                    c(
                                                        "client-type" (
                                                          ("stateful" | "autoconfig")
                                                        ),
                                                        "client-ia-type" (("ia-na" | "ia-pd")),
                                                        "rapid-commit",
                                                        "client-identifier" (
                                                            c(
                                                                "duid-type" (
                                                                  ("duid-llt" | "vendor" | "duid-ll")
                                                                )
                                                            )
                                                        ).as(:oneline),
                                                        "req-option" (("dns-server" | "domain" | "ntp-server" | "time-zone" | "sip-server" | "sip-domain" | "nis-server" | "nis-domain" | "fqdn" | "vendor-spec")),
                                                        "retransmission-attempt" arg,
                                                        "no-dns-propagation",
                                                        "update-router-advertisement" (
                                                            c(
                                                                "interface" arg (
                                                                    c(
                                                                        "managed-configuration",
                                                                        "no-managed-configuration",
                                                                        "other-stateful-configuration",
                                                                        "no-other-stateful-configuration",
                                                                        "max-advertisement-interval" arg,
                                                                        "min-advertisement-interval" arg
                                                                    )
                                                                )
                                                            )
                                                        ),
                                                        "update-server"
                                                    )
                                                ),
                                                "rpf-check" (
                                                    c(
                                                        "fail-filter" arg,
                                                        "mode" (
                                                            c(
                                                                "loose"
                                                            )
                                                        ).as(:oneline)
                                                    )
                                                ),
                                                "accounting" (
                                                    c(
                                                        "source-class-usage" (
                                                            c(
                                                                "input",
                                                                "output"
                                                            )
                                                        ),
                                                        "destination-class-usage"
                                                    )
                                                ),
                                                "mtu" arg,
                                                "tcp-mss" arg,
                                                "nd6-stale-time" arg,
                                                "no-neighbor-learn",
                                                "nd6-max-cache" arg,
                                                "nd6-new-hold-limit" arg,
                                                "no-redirects",
                                                "allow-filter-on-re",
                                                "filter" (
                                                    c(
                                                        c(
                                                          "input" (
                                                              c(
                                                                  arg,
                                                                  "shared-name" arg,
                                                                  "precedence" arg
                                                              )
                                                          ).as(:oneline),
                                                          "input-list" arg
                                                        ),
                                                        c(
                                                          "output" (
                                                              c(
                                                                  arg,
                                                                  "shared-name" arg,
                                                                  "precedence" arg
                                                              )
                                                          ).as(:oneline),
                                                          "output-list" arg
                                                        ),
                                                        "adf" (
                                                            c(
                                                                "rule" arg,
                                                                "counter",
                                                                "input-precedence" arg,
                                                                "not-mandatory",
                                                                "output-precedence" arg
                                                            )
                                                        ),
                                                        "group" arg
                                                    )
                                                ),
                                                "ingress-queuing-filter" (
                                                    c(
                                                        arg
                                                    )
                                                ).as(:oneline),
                                                "input-hierarchical-policer" arg,
                                                "policer" (
                                                    c(
                                                        "input" arg,
                                                        "output" arg
                                                    )
                                                ),
                                                "sampling" (
                                                    c(
                                                        "input",
                                                        "output"
                                                    )
                                                ),
                                                "service" (
                                                    c(
                                                        "input" (
                                                            c(
                                                                "service-set" arg (
                                                                    c(
                                                                        "service-filter" arg
                                                                    )
                                                                ),
                                                                "post-service-filter" arg
                                                            )
                                                        ),
                                                        "output" (
                                                            c(
                                                                "service-set" arg (
                                                                    c(
                                                                        "service-filter" arg
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                ),
                                                "address" arg (
                                                    c(
                                                        "destination" (
                                                          ipv6addr
                                                        ),
                                                        "eui-64",
                                                        "primary",
                                                        "preferred",
                                                        "master-only",
                                                        "ndp" arg (
                                                            c(
                                                                "l2-interface" (
                                                                  interface_name
                                                                ),
                                                                c(
                                                                  "mac" (
                                                                    mac_unicast
                                                                  ),
                                                                  "multicast-mac" (
                                                                    mac_multicast
                                                                  )
                                                                ),
                                                                "publish"
                                                            )
                                                        ).as(:oneline),
                                                        "vrrp-inet6-group" (
                                                          vrrp_group
                                                        ),
                                                        "web-authentication" (
                                                            c(
                                                                "http",
                                                                "https",
                                                                "redirect-to-https"
                                                            )
                                                        ),
                                                        "virtual-gateway-address" (
                                                          ipv6addr
                                                        ),
                                                        "subnet-router-anycast"
                                                    )
                                                ),
                                                "demux-source" ("$junos-subscriber-ipv6-address" | arg | "$junos-subscriber-ipv6-multi-address"),
                                                "demux-destination" ("$junos-subscriber-ipv6-address" | arg),
                                                "unnumbered-address" (
                                                    c(
                                                          interface_unit,
                                                        "preferred-source-address" (
                                                          ("$junos-preferred-source-ipv6-address" | arg)
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "dad-disable",
                                                "no-dad-disable"
                                            )
                                        ),
                                        "mpls" (
                                            c(
                                                "mtu" arg,
                                                "maximum-labels" arg,
                                                "filter" (
                                                    c(
                                                        c(
                                                          "input" arg,
                                                          "input-list" arg
                                                        ),
                                                        c(
                                                          "output" arg,
                                                          "output-list" arg
                                                        ),
                                                        "group" arg
                                                    )
                                                ),
                                                "ingress-queuing-filter" (
                                                    c(
                                                        arg
                                                    )
                                                ).as(:oneline),
                                                "input-hierarchical-policer" arg,
                                                "policer" (
                                                    c(
                                                        "input" arg,
                                                        "output" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "mlppp" (
                                            c(
                                                "bundle" (
                                                  ("$junos-bundle-interface-name" | arg)
                                                ),
                                                c(
                                                  "service-interface" (
                                                    interface_device
                                                  ),
                                                  "service-device-pool" arg
                                                ),
                                                "dynamic-profile" arg
                                            )
                                        ),
                                        "mlfr-end-to-end" (
                                            c(
                                                "bundle" (
                                                  interface_unit
                                                )
                                            )
                                        ),
                                        "mlfr-uni-nni" (
                                            c(
                                                "bundle" (
                                                  interface_unit
                                                )
                                            )
                                        ),
                                        "ccc" (
                                            c(
                                                "mtu" arg,
                                                "filter" (
                                                    c(
                                                        c(
                                                          "input" arg,
                                                          "input-list" arg
                                                        ),
                                                        c(
                                                          "output" arg,
                                                          "output-list" arg
                                                        ),
                                                        "group" arg
                                                    )
                                                ),
                                                "ingress-queuing-filter" (
                                                    c(
                                                        arg
                                                    )
                                                ).as(:oneline),
                                                "policer" (
                                                    c(
                                                        "input" arg,
                                                        "output" arg
                                                    )
                                                ),
                                                "translate-fecn-and-becn",
                                                c(
                                                  "translate-discard-eligible",
                                                  "translate-plp-control-word-de"
                                                ),
                                                "keep-address-and-control"
                                            )
                                        ),
                                        "tcc" (
                                            c(
                                                "policer" (
                                                    c(
                                                        "input" arg,
                                                        "output" arg
                                                    )
                                                ),
                                                "proxy" (
                                                    c(
                                                        "inet-address" (
                                                          ipv4addr
                                                        )
                                                    )
                                                ),
                                                "remote" (
                                                    c(
                                                        "inet-address" (
                                                          ipv4addr
                                                        ),
                                                        "mac-address" (
                                                          mac_addr
                                                        )
                                                    )
                                                ),
                                                "protocols" (
                                                  ("mpls" | "inet" | "iso")
                                                )
                                            )
                                        ),
                                        "vpls" (
                                            c(
                                                "core-facing",
                                                "filter" (
                                                    c(
                                                        c(
                                                          "input" (
                                                              c(
                                                                  arg,
                                                                  "shared-name" arg,
                                                                  "precedence" arg
                                                              )
                                                          ).as(:oneline),
                                                          "input-list" arg
                                                        ),
                                                        c(
                                                          "output" (
                                                              c(
                                                                  arg,
                                                                  "shared-name" arg,
                                                                  "precedence" arg
                                                              )
                                                          ).as(:oneline),
                                                          "output-list" arg
                                                        ),
                                                        "adf" (
                                                            c(
                                                                "rule" arg,
                                                                "counter",
                                                                "input-precedence" arg,
                                                                "not-mandatory",
                                                                "output-precedence" arg
                                                            )
                                                        ),
                                                        "group" arg
                                                    )
                                                ),
                                                "ingress-queuing-filter" (
                                                    c(
                                                        arg
                                                    )
                                                ).as(:oneline),
                                                "policer" (
                                                    c(
                                                        "input" arg,
                                                        "output" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "bridge" (
                                            c(
                                                "core-facing",
                                                "filter" (
                                                    c(
                                                        c(
                                                          "input" (
                                                              c(
                                                                  arg,
                                                                  "shared-name" arg,
                                                                  "precedence" arg
                                                              )
                                                          ).as(:oneline),
                                                          "input-list" arg
                                                        ),
                                                        c(
                                                          "output" (
                                                              c(
                                                                  arg,
                                                                  "shared-name" arg,
                                                                  "precedence" arg
                                                              )
                                                          ).as(:oneline),
                                                          "output-list" arg
                                                        ),
                                                        "adf" (
                                                            c(
                                                                "rule" arg,
                                                                "counter",
                                                                "input-precedence" arg,
                                                                "not-mandatory",
                                                                "output-precedence" arg
                                                            )
                                                        ),
                                                        "group" arg
                                                    )
                                                ),
                                                "ingress-queuing-filter" (
                                                    c(
                                                        arg
                                                    )
                                                ).as(:oneline),
                                                "policer" (
                                                    c(
                                                        "input" arg,
                                                        "output" arg
                                                    )
                                                ),
                                                "interface-mode" (
                                                  ("access" | "trunk")
                                                ),
                                                "vlan-auto-sense",
                                                "bridge-domain-type" (
                                                  ("svlan" | "bvlan")
                                                ),
                                                "inter-switch-link",
                                                c(
                                                  "vlan-id" arg,
                                                  "vlan-id-list" arg,
                                                  "inner-vlan-id-list" arg
                                                ),
                                                "vlan-rewrite" (
                                                    c(
                                                        "translate" arg (
                                                            c(
                                                                  arg
                                                            )
                                                        ).as(:oneline)
                                                    )
                                                ),
                                                c(
                                                  "isid-list" (
                                                    ("all-service-groups" | "all")
                                                  )
                                                ),
                                                "storm-control" (
                                                    c(
                                                        arg
                                                    )
                                                ),
                                                "recovery-timeout" (
                                                    c(
                                                          arg
                                                    )
                                                ).as(:oneline)
                                            )
                                        ),
                                        "ethernet-switching" (
                                          ethernet_switching_type
                                        ),
                                        "fibre-channel" (
                                          fibre_channel_type
                                        ),
                                        "pppoe" (
                                          pppoe_underlying_options_type
                                        ),
                                        "any" (
                                            c(
                                                "filter" (
                                                    c(
                                                        "input" arg,
                                                        "group" arg
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "service-domain" (
                                  ("inside" | "outside")
                                ),
                                "copy-tos-to-outer-ip-header",
                                "copy-tos-to-outer-ip-header-transit",
                                "load-balancing-options" (
                                    c(
                                        "preferred-active" (
                                          interface_device
                                        ),
                                        "hash-keys" (
                                            c(
                                                "ingress-key" (
                                                      (("source-ip" | "destination-ip" | "protocol" | "iif"))
                                                ),
                                                "egress-key" (
                                                      (("source-ip" | "destination-ip" | "protocol" | "oif"))
                                                )
                                            )
                                        )
                                    )
                                ),
                                "mac" (
                                  mac_unicast
                                ),
                                "virtual-gateway-v4-mac" (
                                  mac_unicast
                                ),
                                "virtual-gateway-v6-mac" (
                                  mac_unicast
                                ),
                                "forwarding-options" (
                                    c(
                                        "load-balance-stateful" (
                                            c(
                                                "per-flow",
                                                "rebalance" arg,
                                                "load-type" (
                                                  ("high" | "medium" | "low")
                                                )
                                            )
                                        )
                                    )
                                ),
                                "etree-ac-role" (
                                  ("root" | "leaf")
                                )
                            )
                        ),
                        "no-partition" (
                            c(
                                "interface-type" (
                                  ("e1" | "t1" | "at" | "t3" | "e3" | "ct3" | "so" | "cau4")
                                )
                            )
                        ).as(:oneline),
                        "partition" arg (
                            c(
                                "oc-slice" arg,
                                "timeslots" arg,
                                "interface-type" (
                                  ("ds" | "e1" | "t1" | "at" | "ct1" | "ce1" | "t3" | "ct3" | "e3" | "so" | "coc1" | "cau4" | "dc" | "bc")
                                )
                            )
                        ).as(:oneline),
                        "radius-options" (
                          radius_options_vlan_type
                        )
                    )
                ),
                  interfaces_type
            )
        ),
        "logical-systems" arg (
            c(
                "interfaces" (
                    c(
                        "pic-set" arg (
                            c(
                                "interface" arg,
                                "fpc" arg (
                                    c(
                                        "pic" arg
                                    )
                                )
                            )
                        ),
                        "interface-set" ("$junos-interface-set-name" | arg | "$junos-svlan-interface-set-name" | "$junos-tagged-vlan-interface-set-name" | "$junos-phy-ifd-interface-set-name" | "$junos-pon-id-interface-set-name") (
                            c(
                                "targeted-distribution",
                                "targeted-options",
                                "interface" arg (
                                    c(
                                        "unit" arg,
                                        "vlan-tags-outer" arg
                                    )
                                ),
                                "pppoe-underlying-options" (
                                  pppoe_underlying_options_type
                                )
                            )
                        ),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "flag" (("all" | "kernel" | "change-events" | "kernel-detail" | "config-states" | "resource-usage" | "gres-events" | "select-events" | "bfd-events" | "lib-events" | "reserved" | "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "informational" | "debugging" | "verbose" | "japi")) (
                                    c(
                                        "disable"
                                    )
                                ).as(:oneline)
                            )
                        ),
                        "interface-range" arg (
                            c(
                                "member" arg,
                                "member-range" arg (
                                    c(
                                        "end-range" (
                                          interface_device
                                        )
                                    )
                                ).as(:oneline),
                                "description" arg,
                                "metadata" arg,
                                  ("disable"),
                                "promiscuous-mode",
                                "port-mirror-instance" arg,
                                "multicast-statistics",
                                "oam-on-svlan",
                                "fabric-options" (
                                    c(
                                        "member-interfaces" arg
                                    )
                                ),
                                "traceoptions" (
                                    c(
                                        "flag" (("ipc" | "event" | "media" | "all")).as(:oneline)
                                    )
                                ),
                                "passive-monitor-mode",
                                c(
                                  "keepalives" (
                                    keepalives_type
                                  ).as(:oneline),
                                  "no-keepalives"
                                ),
                                "traps",
                                "no-traps",
                                "interface-mib",
                                "no-interface-mib",
                                "accounting-profile" arg,
                                "anchor-point" (
                                    c(
                                          interface_device
                                    )
                                ),
                                "bypass-queueing-chip",
                                "no-bypass-queueing-chip",
                                c(
                                  "per-unit-scheduler",
                                  "no-per-unit-scheduler",
                                  "shared-scheduler",
                                  "hierarchical-scheduler" (
                                      c(
                                          "maximum-hierarchy-levels" arg,
                                          "implicit-hierarchy"
                                      )
                                  ).as(:oneline)
                                ),
                                "l2tp-maximum-session" arg,
                                "schedulers" arg,
                                "interface-transmit-statistics",
                                "cascade-port",
                                "dce",
                                c(
                                  "vlan-tagging",
                                  "stacked-vlan-tagging",
                                  "flexible-vlan-tagging",
                                  "vlan-vci-tagging"
                                ),
                                "native-vlan-id" arg,
                                "no-native-vlan-insert",
                                "speed" (
                                  ("auto" | "auto-10m-100m" | "10m" | "100m" | "1g" | "10g" | "40g" | "oc3" | "oc12" | "oc48")
                                ),
                                "forwarding-class-accounting" (
                                    c(
                                        "direction" (
                                          ("ingress" | "egress" | "both")
                                        ),
                                        "enhanced" (
                                            c(
                                                "traffic-type" (
                                                  ("unicast-statistics" | "multicast-statistics")
                                                ),
                                                "family" (
                                                  ("inet" | "inet6" | "both")
                                                ),
                                                "direction" (
                                                  ("ingress" | "egress" | "both")
                                                ),
                                                "overhead-bytes" arg
                                            )
                                        )
                                    )
                                ),
                                "auto-configure" (
                                  auto_configure_vlan_type
                                ),
                                "mtu" arg,
                                "hold-time" (
                                    c(
                                        "up" arg,
                                        "down" arg
                                    )
                                ).as(:oneline),
                                "damping" (
                                    c(
                                        "half-life" arg,
                                        "max-suppress" arg,
                                        "reuse" arg,
                                        "suppress" arg,
                                        "enable"
                                    )
                                ),
                                "link-degrade-monitor" (
                                    c(
                                        "actions" (
                                            c(
                                                c(
                                                  "media-based"
                                                )
                                            )
                                        ),
                                        "recovery" (
                                            c(
                                                "timer" arg,
                                                c(
                                                  "auto",
                                                  "manual"
                                                )
                                            )
                                        ),
                                        "thresholds" (
                                            c(
                                                "set" arg,
                                                "clear" arg,
                                                "warning-set" arg,
                                                "warning-clear" arg,
                                                "interval" arg
                                            )
                                        )
                                    )
                                ),
                                "satop-options" (
                                    c(
                                        "idle-pattern" arg,
                                        "payload-size" arg,
                                        "excessive-packet-loss-rate" (
                                            c(
                                                "threshold" arg,
                                                "sample-period" arg
                                            )
                                        ),
                                        c(
                                          "jitter-buffer-packets" arg,
                                          "jitter-buffer-latency" arg,
                                          "jitter-buffer-auto-adjust"
                                        ),
                                        "bit-rate" arg
                                    )
                                ),
                                "cesopsn-options" (
                                    c(
                                        "idle-pattern" arg,
                                        "packetization-latency" arg,
                                        "payload-size" arg,
                                        "excessive-packet-loss-rate" (
                                            c(
                                                "threshold" arg,
                                                "sample-period" arg
                                            )
                                        ),
                                        c(
                                          "jitter-buffer-packets" arg,
                                          "jitter-buffer-latency" arg,
                                          "jitter-buffer-auto-adjust"
                                        ),
                                        "bit-rate" arg
                                    )
                                ),
                                "ima-group-options" (
                                    c(
                                        "frame-length" (
                                          ("32" | "64" | "128" | "256")
                                        ),
                                        "symmetry" (
                                          ("symmetrical-config-and-operation" | "symmetrical-config-asymmetrical-operation")
                                        ),
                                        "transmit-clock" (
                                          ("common" | "independent")
                                        ),
                                        "version" (
                                          ("1.0" | "1.1")
                                        ),
                                        "minimum-links" (
                                            c(
                                                c(
                                                    arg
                                                )
                                            )
                                        ),
                                        "frame-synchronization" (
                                            c(
                                                "alpha" arg,
                                                "beta" arg,
                                                "gamma" arg
                                            )
                                        ),
                                        "test-procedure" (
                                            c(
                                                "period" arg,
                                                "interface" (
                                                  interface_device
                                                ),
                                                "pattern" arg
                                            )
                                        ),
                                        "differential-delay" arg
                                    )
                                ),
                                "ima-link-options" (
                                    c(
                                        "group-id" arg
                                    )
                                ),
                                "multi-chassis-protection" (
                                  multi_chassis_protection_group
                                ),
                                "clocking" (
                                    c(
                                        c(
                                          "internal",
                                          "external"
                                        )
                                    )
                                ).as(:oneline),
                                "link-mode" (
                                  ("automatic" | "half-duplex" | "full-duplex")
                                ),
                                "media-type" (
                                  ("copper" | "fiber")
                                ),
                                "encapsulation" (
                                  ("ethernet" | "fddi" | "token-ring" | "ppp" | "ppp-ccc" | "ppp-tcc" | "ether-vpls-ppp" | "frame-relay" | "frame-relay-ccc" | "frame-relay-tcc" | "extended-frame-relay-ccc" | "extended-frame-relay-tcc" | "flexible-frame-relay" | "frame-relay-port-ccc" | "frame-relay-ether-type" | "frame-relay-ether-type-tcc" | "extended-frame-relay-ether-type-tcc" | "cisco-hdlc" | "cisco-hdlc-ccc" | "cisco-hdlc-tcc" | "vlan-ccc" | "extended-vlan-ccc" | "ethernet-ccc" | "flexible-ethernet-services" | "smds-dxi" | "atm-pvc" | "atm-ccc-cell-relay" | "ethernet-over-atm" | "ethernet-tcc" | "extended-vlan-tcc" | "multilink-frame-relay-uni-nni" | "satop" | "cesopsn" | "ima" | "ethernet-vpls" | "ethernet-bridge" | "vlan-vpls" | "vlan-vci-ccc" | "extended-vlan-vpls" | "extended-vlan-bridge" | "multilink-ppp" | "generic-services")
                                ),
                                "esi" (
                                    c(
                                          esi,
                                        c(
                                          "single-active",
                                          "all-active"
                                        ),
                                        "source-bmac" (
                                          mac_unicast
                                        )
                                    )
                                ),
                                "framing" (
                                    c(
                                        c(
                                          "lan-phy",
                                          "wan-phy",
                                          "sonet",
                                          "sdh"
                                        )
                                    )
                                ),
                                "unidirectional",
                                "lmi" (
                                    c(
                                        "n391dte" arg,
                                        "n392dce" arg,
                                        "n392dte" arg,
                                        "n393dce" arg,
                                        "n393dte" arg,
                                        "t391dte" arg,
                                        "t392dce" arg,
                                        "lmi-type" (
                                          ("ansi" | "itu" | "c-lmi")
                                        )
                                    )
                                ),
                                "mlfr-uni-nni-bundle-options" (
                                    c(
                                        "cisco-interoperability" (
                                            c(
                                                "send-lip-remove-link-for-link-reject"
                                            )
                                        ),
                                        "mrru" arg,
                                        "yellow-differential-delay" arg,
                                        "red-differential-delay" arg,
                                        "action-red-differential-delay" (
                                          ("remove-link" | "disable-tx")
                                        ),
                                        "fragment-threshold" arg,
                                        "drop-timeout" arg,
                                        "link-layer-overhead" (
                                          unsigned_float
                                        ),
                                        "lmi-type" (
                                          ("ansi" | "itu" | "c-lmi")
                                        ),
                                        "minimum-links" arg,
                                        "hello-timer" arg,
                                        "acknowledge-timer" arg,
                                        "acknowledge-retries" arg,
                                        "n391" arg,
                                        "n392" arg,
                                        "n393" arg,
                                        "t391" arg,
                                        "t392" arg
                                    )
                                ),
                                "mac" (
                                  mac_unicast
                                ),
                                "receive-bucket" (
                                  dcd_rx_bucket_config
                                ),
                                "transmit-bucket" (
                                  dcd_tx_bucket_config
                                ),
                                "shared-interface",
                                "sonet-options" (
                                  sonet_options_type
                                ),
                                "logical-tunnel-options" (
                                    c(
                                        "per-unit-mac-disable"
                                    )
                                ),
                                "aggregated-sonet-options" (
                                    c(
                                        "minimum-links" arg,
                                        "link-speed" (
                                          ("oc3" | "oc12" | "oc48" | "oc192" | "oc768" | "mixed")
                                        ),
                                        "minimum-bandwidth" arg
                                    )
                                ),
                                "atm-options" (
                                    c(
                                        "pic-type" (
                                          ("atm-ce" | "atm2" | "atm1")
                                        ),
                                        "cell-bundle-size" arg,
                                        "cell-bundle-timeout" arg,
                                        "plp-to-clp",
                                        "use-null-cw",
                                        "promiscuous-mode" (
                                            c(
                                                "vpi" arg.as(:oneline)
                                            )
                                        ),
                                        "vpi" arg (
                                            c(
                                                "maximum-vcs" arg,
                                                "shaping" (
                                                  dcd_shaping_config
                                                ),
                                                "oam-period" (
                                                    c(
                                                        c(
                                                            arg,
                                                          "disable".as(:oneline)
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "oam-liveness" (
                                                    c(
                                                        "up-count" arg,
                                                        "down-count" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "ilmi",
                                        "linear-red-profiles" arg (
                                            c(
                                                "queue-depth" arg,
                                                "high-plp-threshold" arg,
                                                "low-plp-threshold" arg,
                                                "high-plp-max-threshold" arg,
                                                "low-plp-max-threshold" arg
                                            )
                                        ).as(:oneline),
                                        "scheduler-maps" arg (
                                            c(
                                                "vc-cos-mode" (
                                                  ("strict" | "alternate")
                                                ),
                                                "forwarding-class" arg (
                                                    c(
                                                        "priority" (
                                                          ("low" | "high")
                                                        ),
                                                        "transmit-weight" (
                                                            c(
                                                                c(
                                                                  "percent" arg,
                                                                  "cells" arg
                                                                )
                                                            )
                                                        ).as(:oneline),
                                                        c(
                                                          "epd-threshold" (
                                                            epd_threshold_config
                                                          ).as(:oneline),
                                                          "linear-red-profile" arg
                                                        )
                                                    )
                                                )
                                            )
                                        ),
                                        "mpls" (
                                          mpls_ifd_options
                                        ),
                                        "payload-scrambler",
                                        "no-payload-scrambler"
                                    )
                                ),
                                "multiservice-options" (
                                    c(
                                        "syslog",
                                        "no-syslog",
                                        "core-dump",
                                        "no-core-dump",
                                        "dump-on-flow-control",
                                        "no-dump-on-flow-control",
                                        "reset-on-flow-control",
                                        "no-reset-on-flow-control",
                                        "flow-control-options" (
                                            c(
                                                "dump-on-flow-control",
                                                "reset-on-flow-control",
                                                "down-on-flow-control"
                                            )
                                        )
                                    )
                                ),
                                "ggsn-options" (
                                    c(
                                        "syslog",
                                        "no-syslog",
                                        "core-dump",
                                        "no-core-dump"
                                    )
                                ),
                                "ppp-options" (
                                  ppp_options_type
                                ),
                                "redundancy-options" (
                                    c(
                                        "primary" (
                                          interface_device
                                        ),
                                        "secondary" (
                                          interface_device
                                        ),
                                        "redundancy-peer" (
                                            c(
                                                "ipaddress" (
                                                  ipv4addr
                                                )
                                            )
                                        ),
                                        "redundancy-local" (
                                            c(
                                                "data-address" (
                                                  ipv4addr
                                                )
                                            )
                                        ),
                                        "routing-instance" arg,
                                        "replication-threshold" arg,
                                        "replication-options" (
                                            c(
                                                "mtu" arg
                                            )
                                        ),
                                        "replicate-services" (
                                            c(
                                                "pgcp"
                                            )
                                        )
                                    )
                                ),
                                "load-balancing-options" (
                                    c(
                                        "member-interface" arg,
                                        "member-failure-options" (
                                            c(
                                                c(
                                                  "redistribute-all-traffic" (
                                                      c(
                                                          "enable-rejoin"
                                                      )
                                                  ),
                                                  "drop-member-traffic" (
                                                      c(
                                                          "rejoin-timeout" arg,
                                                          "enable-rejoin"
                                                      )
                                                  )
                                                )
                                            )
                                        ),
                                        "high-availability-options" (
                                            c(
                                                c(
                                                  "many-to-one" (
                                                      c(
                                                          "preferred-backup" (
                                                            interface_device
                                                          )
                                                      )
                                                  ),
                                                  "one-to-one" (
                                                      c(
                                                          "preferred-backup" (
                                                            interface_device
                                                          )
                                                      )
                                                  )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "aggregated-inline-services-options" (
                                    c(
                                        "primary-interface" (
                                          interface_device
                                        ),
                                        "secondary-interface" (
                                          interface_device
                                        )
                                    )
                                ),
                                "anchoring-options" (
                                    c(
                                        "apfe-group-set" arg,
                                        "primary-list" arg,
                                        "secondary" (
                                            c(
                                                arg
                                            )
                                        ),
                                        c(
                                          "warm-standby"
                                        )
                                    )
                                ),
                                "lsq-failure-options" (
                                    c(
                                        "trigger-link-failure" arg,
                                        "no-termination-request",
                                        "no-no-termination-request"
                                    )
                                ),
                                "redundancy-group" (
                                    c(
                                        "member-interface" arg (
                                            c(
                                                c(
                                                  "active",
                                                  "backup"
                                                )
                                            )
                                        ),
                                        "maximum-links" arg
                                    )
                                ),
                                "services-options" (
                                    c(
                                        "syslog" (
                                          service_set_syslog_object
                                        ),
                                        "jflow-log" (
                                            c(
                                                "message-rate-limit" arg
                                            )
                                        ),
                                        "open-timeout" arg,
                                        "close-timeout" arg,
                                        "inactivity-timeout" arg,
                                        "inactivity-tcp-timeout" arg,
                                        "inactivity-asymm-tcp-timeout" arg,
                                        "inactivity-non-tcp-timeout" arg,
                                        "session-timeout" arg,
                                        "disable-global-timeout-override",
                                        "tcp-tickles" arg,
                                        "trio-flow-offload" (
                                            c(
                                                "minimum-bytes" arg
                                            )
                                        ),
                                        "fragment-limit" arg,
                                        "reassembly-timeout" arg,
                                        "cgn-pic",
                                        "pba-interim-logging-interval" arg,
                                        "session-limit" (
                                            c(
                                                "maximum" arg,
                                                "rate" arg,
                                                "cpu-load-threshold" arg
                                            )
                                        ),
                                        "ignore-errors" (
                                            c(
                                                "tcp",
                                                "alg"
                                            )
                                        ).as(:oneline),
                                        "capture" (
                                            c(
                                                "capture-size" arg,
                                                "pkt-size" arg,
                                                "logs-per-packet" arg,
                                                "max-log-line-size" arg,
                                                "filter" (
                                                    c(
                                                        "source-ip" (
                                                            c(
                                                                  ipaddr,
                                                                "wildcard" (
                                                                  ipaddr
                                                                )
                                                            )
                                                        ).as(:oneline),
                                                        "dest-ip" (
                                                            c(
                                                                  ipaddr,
                                                                "wildcard" (
                                                                  ipaddr
                                                                )
                                                            )
                                                        ).as(:oneline),
                                                        "sw-sip" (
                                                            c(
                                                                  ipv6addr,
                                                                "wildcard" (
                                                                  ipv6addr
                                                                )
                                                            )
                                                        ).as(:oneline),
                                                        "sw-dip" (
                                                            c(
                                                                  ipaddr,
                                                                "wildcard" (
                                                                  ipaddr
                                                                )
                                                            )
                                                        ).as(:oneline),
                                                        "sport-range" (
                                                            c(
                                                                "low" arg,
                                                                "high" arg
                                                            )
                                                        ).as(:oneline),
                                                        "dport-range" (
                                                            c(
                                                                "low" arg,
                                                                "high" arg
                                                            )
                                                        ).as(:oneline),
                                                        "proto" (
                                                          ("icmp" | "tcp" | "udp")
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "t3-options" (
                                    c(
                                        "loopback" (
                                          ("local" | "remote" | "payload")
                                        ),
                                        "long-buildout",
                                        "no-long-buildout",
                                        "loop-timing",
                                        "no-loop-timing",
                                        "unframed",
                                        "no-unframed",
                                        "compatibility-mode" (
                                            c(
                                                c(
                                                  "larscom" (
                                                      c(
                                                          "subrate" arg
                                                      )
                                                  ).as(:oneline),
                                                  "verilink" (
                                                      c(
                                                          "subrate" arg
                                                      )
                                                  ).as(:oneline),
                                                  "adtran" (
                                                      c(
                                                          "subrate" arg
                                                      )
                                                  ).as(:oneline),
                                                  "kentrox" (
                                                      c(
                                                          "subrate" arg
                                                      )
                                                  ).as(:oneline),
                                                  "digital-link" (
                                                      c(
                                                          "subrate" (
                                                            ("301Kb" | "601Kb" | "902Kb" | "1.2Mb" | "1.5Mb" | "1.8Mb" | "2.1Mb" | "2.4Mb" | "2.7Mb" | "3.0Mb" | "3.3Mb" | "3.6Mb" | "3.9Mb" | "4.2Mb" | "4.5Mb" | "4.8Mb" | "5.1Mb" | "5.4Mb" | "5.7Mb" | "6.0Mb" | "6.3Mb" | "6.6Mb" | "6.9Mb" | "7.2Mb" | "7.5Mb" | "7.8Mb" | "8.1Mb" | "8.4Mb" | "8.7Mb" | "9.0Mb" | "9.3Mb" | "9.6Mb" | "9.9Mb" | "10.2Mb" | "10.5Mb" | "10.8Mb" | "11.1Mb" | "11.4Mb" | "11.7Mb" | "12.0Mb" | "12.3Mb" | "12.6Mb" | "12.9Mb" | "13.2Mb" | "13.5Mb" | "13.8Mb" | "14.1Mb" | "14.4Mb" | "14.7Mb" | "15.0Mb" | "15.3Mb" | "15.6Mb" | "15.9Mb" | "16.2Mb" | "16.5Mb" | "16.8Mb" | "17.1Mb" | "17.4Mb" | "17.7Mb" | "18.0Mb" | "18.3Mb" | "18.6Mb" | "18.9Mb" | "19.2Mb" | "19.5Mb" | "19.8Mb" | "20.1Mb" | "20.5Mb" | "20.8Mb" | "21.1Mb" | "21.4Mb" | "21.7Mb" | "22.0Mb" | "22.3Mb" | "22.6Mb" | "22.9Mb" | "23.2Mb" | "23.5Mb" | "23.8Mb" | "24.1Mb" | "24.4Mb" | "24.7Mb" | "25.0Mb" | "25.3Mb" | "25.6Mb" | "25.9Mb" | "26.2Mb" | "26.5Mb" | "26.8Mb" | "27.1Mb" | "27.4Mb" | "27.7Mb" | "28.0Mb" | "28.3Mb" | "28.6Mb" | "28.9Mb" | "29.2Mb" | "29.5Mb" | "29.8Mb" | "30.1Mb" | "30.4Mb" | "30.7Mb" | "31.0Mb" | "31.3Mb" | "31.6Mb" | "31.9Mb" | "32.2Mb" | "32.5Mb" | "32.8Mb" | "33.1Mb" | "33.4Mb" | "33.7Mb" | "34.0Mb" | "34.3Mb" | "34.6Mb" | "34.9Mb" | "35.2Mb" | "35.5Mb" | "35.8Mb" | "36.1Mb" | "36.4Mb" | "36.7Mb" | "37.0Mb" | "37.3Mb" | "37.6Mb" | "37.9Mb" | "38.2Mb" | "38.5Mb" | "38.8Mb" | "39.1Mb" | "39.4Mb" | "39.7Mb" | "40.0Mb" | "40.3Mb" | "40.6Mb" | "40.9Mb" | "41.2Mb" | "41.5Mb" | "41.8Mb" | "42.1Mb" | "42.4Mb" | "42.7Mb" | "43.0Mb" | "43.3Mb" | "43.6Mb" | "43.9Mb" | "44.2Mb")
                                                          )
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ).as(:oneline),
                                        "payload-scrambler",
                                        "no-payload-scrambler",
                                        "cbit-parity",
                                        "no-cbit-parity",
                                        "fcs" (
                                          ("32" | "16")
                                        ),
                                        "idle-cycle-flag" (
                                          ("flags" | "ones")
                                        ),
                                        "start-end-flag" (
                                          ("shared" | "filler")
                                        ),
                                        "feac-loop-respond",
                                        "no-feac-loop-respond",
                                        "bert-algorithm" (
                                          ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                        ),
                                        "bert-error-rate" arg,
                                        "bert-period" arg,
                                        "buildout" arg,
                                        "atm-encapsulation" (
                                          ("plcp" | "direct")
                                        )
                                    )
                                ),
                                "e3-options" (
                                    c(
                                        "loopback" (
                                          ("local" | "remote")
                                        ),
                                        "unframed",
                                        "no-unframed",
                                        "compatibility-mode" (
                                            c(
                                                c(
                                                  "larscom",
                                                  "digital-link" (
                                                      c(
                                                          "subrate" (
                                                            ("358Kb" | "716Kb" | "1.1Mb" | "1.4Mb" | "1.8Mb" | "2.1Mb" | "2.5Mb" | "2.9Mb" | "3.2Mb" | "3.6Mb" | "3.9Mb" | "4.3Mb" | "4.7Mb" | "5.0Mb" | "5.4Mb" | "5.7Mb" | "6.1Mb" | "6.4Mb" | "6.8Mb" | "7.2Mb" | "7.5Mb" | "7.9Mb" | "8.2Mb" | "8.6Mb" | "9.0Mb" | "9.3Mb" | "9.7Mb" | "10.0Mb" | "10.4Mb" | "10.7Mb" | "11.1Mb" | "11.5Mb" | "11.8Mb" | "12.2Mb" | "12.5Mb" | "12.9Mb" | "13.2Mb" | "13.6Mb" | "14.0Mb" | "14.3Mb" | "14.7Mb" | "15.0Mb" | "15.4Mb" | "15.8Mb" | "16.1Mb" | "16.5Mb" | "16.8Mb" | "17.2Mb" | "17.5Mb" | "17.9Mb" | "18.3Mb" | "18.6Mb" | "19.0Mb" | "19.3Mb" | "19.7Mb" | "20.0Mb" | "20.4Mb" | "20.8Mb" | "21.1Mb" | "21.5Mb" | "21.8Mb" | "22.2Mb" | "22.6Mb" | "22.9Mb" | "23.3Mb" | "23.6Mb" | "24.0Mb" | "24.3Mb" | "24.7Mb" | "25.1Mb" | "25.4Mb" | "25.8Mb" | "26.1Mb" | "26.5Mb" | "26.9Mb" | "27.2Mb" | "27.6Mb" | "27.9Mb" | "28.3Mb" | "28.6Mb" | "29.0Mb" | "29.4Mb" | "29.7Mb" | "30.1Mb" | "30.4Mb" | "30.8Mb" | "31.1Mb" | "31.5Mb" | "31.9Mb" | "32.2Mb" | "32.6Mb" | "32.9Mb" | "33.3Mb" | "33.7Mb" | "34.0Mb")
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "kentrox" (
                                                      c(
                                                          "subrate" arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ).as(:oneline),
                                        "payload-scrambler",
                                        "no-payload-scrambler",
                                        "fcs" (
                                          ("32" | "16")
                                        ),
                                        "idle-cycle-flag" (
                                          ("flags" | "ones")
                                        ),
                                        "invert-data",
                                        "start-end-flag" (
                                          ("shared" | "filler")
                                        ),
                                        "bert-algorithm" (
                                          ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                        ),
                                        "bert-error-rate" arg,
                                        "bert-period" arg,
                                        "buildout" arg,
                                        "atm-encapsulation" (
                                          ("plcp" | "direct")
                                        ),
                                        "framing" (
                                          ("g.751" | "g.832")
                                        )
                                    )
                                ),
                                "e1-options" (
                                    c(
                                        "timeslots" arg,
                                        "loopback" (
                                          ("local" | "remote")
                                        ),
                                        "framing" (
                                          ("g704" | "unframed" | "g704-no-crc4")
                                        ),
                                        "fcs" (
                                          ("32" | "16")
                                        ),
                                        "invert-data",
                                        "idle-cycle-flag" (
                                          ("flags" | "ones")
                                        ),
                                        "start-end-flag" (
                                          ("shared" | "filler")
                                        ),
                                        "bert-algorithm" (
                                          ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                        ),
                                        "bert-error-rate" arg,
                                        "bert-period" arg
                                    )
                                ),
                                "t1-options" (
                                    c(
                                        "timeslots" arg,
                                        "voice-timeslots" arg,
                                        "disable-remote-alarm-detection" (
                                          ("yellow")
                                        ),
                                        "loopback" (
                                          ("local" | "remote" | "payload")
                                        ),
                                        "buildout" (
                                          ("0-132" | "133-265" | "266-398" | "399-531" | "532-655" | "long-0db" | "long-7.5db" | "long-15db" | "long-22.5db")
                                        ),
                                        "byte-encoding" (
                                          ("nx64" | "nx56")
                                        ),
                                        "line-encoding" (
                                          ("ami" | "b8zs")
                                        ),
                                        "invert-data",
                                        "framing" (
                                          ("sf" | "esf")
                                        ),
                                        "fcs" (
                                          ("32" | "16")
                                        ),
                                        "idle-cycle-flag" (
                                          ("flags" | "ones")
                                        ),
                                        "start-end-flag" (
                                          ("shared" | "filler")
                                        ),
                                        "bert-algorithm" (
                                          ("pseudo-2e3" | "pseudo-2e4" | "pseudo-2e5" | "pseudo-2e6" | "pseudo-2e7" | "pseudo-2e9-o153" | "pseudo-2e10" | "pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e17" | "pseudo-2e18" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "pseudo-2e21" | "pseudo-2e22" | "pseudo-2e23-o151" | "pseudo-2e25" | "pseudo-2e28" | "pseudo-2e29" | "pseudo-2e31" | "pseudo-2e32" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4")
                                        ),
                                        "bert-error-rate" arg,
                                        "bert-period" arg,
                                        "remote-loopback-respond",
                                        "crc-major-alarm-threshold" (
                                          ("1e-3" | "5e-4" | "1e-4" | "5e-5" | "1e-5")
                                        ),
                                        "crc-minor-alarm-threshold" (
                                          ("1e-3" | "5e-4" | "1e-4" | "5e-5" | "1e-5" | "5e-6" | "1e-6")
                                        ),
                                        "alarm-compliance" (
                                          ("accunet-t1-5-service")
                                        )
                                    )
                                ),
                                "ds0-options" (
                                    c(
                                        "loopback" (
                                          ("payload")
                                        ),
                                        "byte-encoding" (
                                          ("nx64" | "nx56")
                                        ),
                                        "invert-data",
                                        "fcs" (
                                          ("32" | "16")
                                        ),
                                        "idle-cycle-flag" (
                                          ("flags" | "ones")
                                        ),
                                        "start-end-flag" (
                                          ("shared" | "filler")
                                        ),
                                        "bert-algorithm" (
                                          ("pseudo-2e11-o152" | "pseudo-2e15-o151" | "pseudo-2e20-o153" | "pseudo-2e20-o151" | "all-ones-repeating" | "all-zeros-repeating" | "alternating-ones-zeros" | "alternating-double-ones-zeros" | "repeating-3-in-24" | "repeating-1-in-8" | "repeating-1-in-4" | "repeating-1-in-16")
                                        ),
                                        "bert-error-rate" arg,
                                        "bert-period" arg
                                    )
                                ),
                                "serial-options" (
                                    c(
                                        "line-protocol" (
                                          ("eia530" | "v.35" | "x.21")
                                        ),
                                        c(
                                          "dte-options" (
                                              c(
                                                  "ignore-all",
                                                  "dtr" (
                                                      c(
                                                          c(
                                                            "assert",
                                                            "de-assert",
                                                            "normal",
                                                            "auto-synchronize" (
                                                                c(
                                                                    "duration" arg,
                                                                    "interval" arg
                                                                )
                                                            )
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "control-signal" (
                                                    ("assert" | "de-assert" | "normal")
                                                  ),
                                                  "rts" (
                                                    ("assert" | "de-assert" | "normal")
                                                  ),
                                                  "dcd" (
                                                    ("require" | "ignore" | "normal")
                                                  ),
                                                  "dsr" (
                                                    ("require" | "ignore" | "normal")
                                                  ),
                                                  "cts" (
                                                    ("require" | "ignore" | "normal")
                                                  ),
                                                  "indication" (
                                                    ("require" | "ignore" | "normal")
                                                  ),
                                                  "tm" (
                                                    ("require" | "ignore" | "normal")
                                                  )
                                              )
                                          ),
                                          "dce-options" (
                                              c(
                                                  "ignore-all",
                                                  "dtr" (
                                                    ("require" | "ignore" | "normal")
                                                  ),
                                                  "rts" (
                                                    ("require" | "ignore" | "normal")
                                                  ),
                                                  "dcd" (
                                                    ("assert" | "de-assert" | "normal")
                                                  ),
                                                  "dsr" (
                                                    ("assert" | "de-assert" | "normal")
                                                  ),
                                                  "cts" (
                                                    ("assert" | "de-assert" | "normal")
                                                  ),
                                                  "tm" (
                                                    ("require" | "ignore" | "normal")
                                                  ),
                                                  "dce-loopback-override"
                                              )
                                          )
                                        ),
                                        "dtr-circuit" (
                                          ("balanced" | "unbalanced")
                                        ),
                                        "dtr-polarity" (
                                          ("positive" | "negative")
                                        ),
                                        "rts-polarity" (
                                          ("positive" | "negative")
                                        ),
                                        "control-polarity" (
                                          ("positive" | "negative")
                                        ),
                                        "dcd-polarity" (
                                          ("positive" | "negative")
                                        ),
                                        "dsr-polarity" (
                                          ("positive" | "negative")
                                        ),
                                        "cts-polarity" (
                                          ("positive" | "negative")
                                        ),
                                        "indication-polarity" (
                                          ("positive" | "negative")
                                        ),
                                        "tm-polarity" (
                                          ("positive" | "negative")
                                        ),
                                        "clocking-mode" (
                                          ("dce" | "internal" | "loop")
                                        ),
                                        "transmit-clock" (
                                          ("invert")
                                        ),
                                        "clock-rate" (
                                          ("2.048mhz" | "2.341mhz" | "2.731mhz" | "3.277mhz" | "4.096mhz" | "5.461mhz" | "8.192mhz" | "16.384mhz" | "1.2khz" | "2.4khz" | "9.6khz" | "19.2khz" | "38.4khz" | "56.0khz" | "64.0khz" | "72.0khz" | "125.0khz" | "148.0khz" | "250.0khz" | "500.0khz" | "800.0khz" | "1.0mhz" | "1.3mhz" | "2.0mhz" | "4.0mhz" | "8.0mhz")
                                        ),
                                        "loopback" (
                                          ("local" | "remote" | "dce-local" | "dce-remote")
                                        ),
                                        "encoding" (
                                          ("nrz" | "nrzi")
                                        ),
                                        "idle-cycle-flag" (
                                          ("flags" | "ones")
                                        )
                                    )
                                ),
                                "gratuitous-arp-reply",
                                "no-gratuitous-arp-reply",
                                "no-gratuitous-arp-request",
                                "no-no-gratuitous-arp-request",
                                "arp-l2-validate",
                                "ether-options" (
                                    c(
                                        "loopback",
                                        "no-loopback",
                                        "source-filtering",
                                        "no-source-filtering",
                                        "ethernet-switch-profile" (
                                            c(
                                                "tag-protocol-id" arg,
                                                "ethernet-policer-profile" (
                                                    c(
                                                        "input-priority-map" (
                                                          cos_policer_input_priority_map
                                                        ),
                                                        "output-priority-map" (
                                                          cos_policer_output_priority_map
                                                        ),
                                                        "policer" (
                                                          cos_policer
                                                        )
                                                    )
                                                ),
                                                "storm-control" (
                                                    c(
                                                        arg
                                                    )
                                                ),
                                                "recovery-timeout" (
                                                    c(
                                                          arg
                                                    )
                                                ).as(:oneline),
                                                "mac-learn-enable",
                                                "no-mac-learn-enable"
                                            )
                                        ),
                                        "asynchronous-notification",
                                        "source-address-filter" arg.as(:oneline),
                                        "auto-negotiation",
                                        "no-auto-negotiation",
                                        "flow-control",
                                        "no-flow-control",
                                        "configured-flow-control" (
                                            c(
                                                "rx-buffers" (
                                                  ("on" | "off")
                                                ),
                                                "tx-buffers" (
                                                  ("on" | "off")
                                                )
                                            )
                                        ),
                                        "link-mode" (
                                          ("automatic" | "half-duplex" | "full-duplex")
                                        ),
                                        "mpls" (
                                          mpls_ifd_options
                                        ),
                                        "ignore-l3-incompletes",
                                        "no-auto-mdix",
                                        "speed" (
                                            c(
                                                c(
                                                  "auto-negotiation" (
                                                      c(
                                                          "auto-negotiate-10-100"
                                                      )
                                                  ).as(:oneline),
                                                  "ethernet-10m",
                                                  "ethernet-100m",
                                                  "ethernet-1g",
                                                  "ethernet-10g"
                                                )
                                            )
                                        ),
                                        "ieee-802.3ad" (
                                            c(
                                                "lacp" (
                                                    c(
                                                        "force-up",
                                                        "port-priority" arg
                                                    )
                                                ),
                                                  interface_device,
                                                c(
                                                  "primary",
                                                  "backup"
                                                ),
                                                "link-protection-sub-group" (
                                                    c(
                                                          arg
                                                    )
                                                ),
                                                "port-priority" arg
                                            )
                                        ),
                                        "ieee-802-3az-eee",
                                        "mdi-mode" (
                                          ("auto" | "force" | "mdi" | "mdix")
                                        ),
                                        "redundant-parent" (
                                            c(
                                                  interface_device
                                            )
                                        ),
                                        "autostate-exclude"
                                    )
                                ),
                                "fibrechannel-options" (
                                    c(
                                        "loopback",
                                        "no-loopback",
                                        "bb-sc-n" arg,
                                        "speed" (
                                          ("auto-negotiation" | "1g" | "2g" | "4g" | "8g")
                                        )
                                    )
                                ),
                                "gigether-options" (
                                    c(
                                        "loopback",
                                        "no-loopback",
                                        "loopback-remote",
                                        "flow-control",
                                        "no-flow-control",
                                        "source-filtering",
                                        "no-source-filtering",
                                        c(
                                          "no-auto-negotiation",
                                          "auto-negotiation" (
                                              c(
                                                  "remote-fault" (
                                                    ("local-interface-offline" | "local-interface-online")
                                                  )
                                              )
                                          ).as(:oneline)
                                        ),
                                        "mac-mode" (
                                          ("sgmii" | "mac-mode-1000base-x")
                                        ),
                                        "asynchronous-notification",
                                        "source-address-filter" arg.as(:oneline),
                                        "pad-to-minimum-frame-size",
                                        "redundant-parent" (
                                            c(
                                                  interface_device
                                            )
                                        ),
                                        "ieee-802.3ad" (
                                            c(
                                                "lacp" (
                                                    c(
                                                        "port-priority" arg
                                                    )
                                                ),
                                                  interface_device,
                                                "link-index" arg,
                                                c(
                                                  "primary",
                                                  "backup"
                                                ),
                                                "distribution-list" arg
                                            )
                                        ),
                                        "ethernet-switch-profile" (
                                            c(
                                                "tag-protocol-id" arg,
                                                "ethernet-policer-profile" (
                                                    c(
                                                        "ieee802.1-priority-map" (
                                                            c(
                                                                "premium" arg
                                                            )
                                                        ),
                                                        "input-priority-map" (
                                                          cos_policer_input_priority_map
                                                        ),
                                                        "output-priority-map" (
                                                          cos_policer_output_priority_map
                                                        ),
                                                        "policer" (
                                                          cos_policer
                                                        )
                                                    )
                                                ),
                                                "accept-from" (
                                                    c(
                                                        "mac-address" (
                                                          mac_list
                                                        )
                                                    )
                                                ),
                                                "reject-the-rest",
                                                "no-reject-the-rest",
                                                "mac-learn-enable"
                                            )
                                        ),
                                        "mpls" (
                                          mpls_ifd_options
                                        ),
                                        "ignore-l3-incompletes",
                                        "no-auto-mdix",
                                        "ieee-802-3az-eee",
                                        "mru" arg,
                                        "fec" (
                                          ("none" | "fec91" | "fec74")
                                        )
                                    )
                                ),
                                "optics-options" (
                                    c(
                                        "wavelength" (
                                          ("1568.77" | "1568.36" | "1568.26" | "1568.16" | "1568.05" | "1567.95" | "1567.85" | "1567.75" | "1567.64" | "1567.54" | "1567.44" | "1567.34" | "1567.23" | "1567.13" | "1567.03" | "1566.93" | "1566.83" | "1566.72" | "1566.62" | "1566.52" | "1566.42" | "1566.31" | "1566.21" | "1566.11" | "1566.01" | "1565.90" | "1565.80" | "1565.70" | "1565.60" | "1565.50" | "1565.39" | "1565.29" | "1565.19" | "1565.09" | "1564.99" | "1564.88" | "1564.78" | "1564.68" | "1564.58" | "1564.47" | "1564.37" | "1564.27" | "1564.17" | "1564.07" | "1563.96" | "1563.86" | "1563.76" | "1563.66" | "1563.56" | "1563.45" | "1563.35" | "1563.25" | "1563.15" | "1563.05" | "1562.95" | "1562.84" | "1562.74" | "1562.64" | "1562.54" | "1562.44" | "1562.33" | "1562.23" | "1562.13" | "1562.03" | "1561.93" | "1561.83" | "1561.72" | "1561.62" | "1561.52" | "1561.42" | "1561.32" | "1561.22" | "1561.11" | "1561.01" | "1560.91" | "1560.81" | "1560.71" | "1560.61" | "1560.50" | "1560.40" | "1560.30" | "1560.20" | "1560.10" | "1560.00" | "1559.90" | "1559.79" | "1559.69" | "1559.59" | "1559.49" | "1559.39" | "1559.29" | "1559.19" | "1559.08" | "1558.98" | "1558.88" | "1558.78" | "1558.68" | "1558.58" | "1558.48" | "1558.38" | "1558.27" | "1558.17" | "1558.07" | "1557.97" | "1557.87" | "1557.77" | "1557.67" | "1557.57" | "1557.46" | "1557.36" | "1557.26" | "1557.16" | "1557.06" | "1556.96" | "1556.86" | "1556.76" | "1556.66" | "1556.55" | "1556.45" | "1556.35" | "1556.25" | "1556.15" | "1556.05" | "1555.95" | "1555.85" | "1555.75" | "1555.65" | "1555.55" | "1555.44" | "1555.34" | "1555.24" | "1555.14" | "1555.04" | "1554.94" | "1554.84" | "1554.74" | "1554.64" | "1554.54" | "1554.44" | "1554.34" | "1554.23" | "1554.13" | "1554.03" | "1553.93" | "1553.83" | "1553.73" | "1553.63" | "1553.53" | "1553.43" | "1553.33" | "1553.23" | "1553.13" | "1553.03" | "1552.93" | "1552.83" | "1552.73" | "1552.62" | "1552.52" | "1552.42" | "1552.32" | "1552.22" | "1552.12" | "1552.02" | "1551.92" | "1551.82" | "1551.72" | "1551.62" | "1551.52" | "1551.42" | "1551.32" | "1551.22" | "1551.12" | "1551.02" | "1550.92" | "1550.82" | "1550.72" | "1550.62" | "1550.52" | "1550.42" | "1550.32" | "1550.22" | "1550.12" | "1550.02" | "1549.92" | "1549.82" | "1549.72" | "1549.62" | "1549.52" | "1549.42" | "1549.32" | "1549.21" | "1549.11" | "1549.01" | "1548.91" | "1548.81" | "1548.71" | "1548.61" | "1548.51" | "1548.41" | "1548.31" | "1548.21" | "1548.11" | "1548.02" | "1547.92" | "1547.82" | "1547.72" | "1547.62" | "1547.52" | "1547.42" | "1547.32" | "1547.22" | "1547.12" | "1547.02" | "1546.92" | "1546.82" | "1546.72" | "1546.62" | "1546.52" | "1546.42" | "1546.32" | "1546.22" | "1546.12" | "1546.02" | "1545.92" | "1545.82" | "1545.72" | "1545.62" | "1545.52" | "1545.42" | "1545.32" | "1545.22" | "1545.12" | "1545.02" | "1544.92" | "1544.82" | "1544.72" | "1544.63" | "1544.53" | "1544.43" | "1544.33" | "1544.23" | "1544.13" | "1544.03" | "1543.93" | "1543.83" | "1543.73" | "1543.63" | "1543.53" | "1543.43" | "1543.33" | "1543.23" | "1543.13" | "1543.04" | "1542.94" | "1542.84" | "1542.74" | "1542.64" | "1542.54" | "1542.44" | "1542.34" | "1542.24" | "1542.14" | "1542.04" | "1541.94" | "1541.84" | "1541.75" | "1541.65" | "1541.55" | "1541.45" | "1541.35" | "1541.25" | "1541.15" | "1541.05" | "1540.95" | "1540.85" | "1540.76" | "1540.66" | "1540.56" | "1540.46" | "1540.36" | "1540.26" | "1540.16" | "1540.06" | "1539.96" | "1539.86" | "1539.77" | "1539.67" | "1539.57" | "1539.47" | "1539.37" | "1539.27" | "1539.17" | "1539.07" | "1538.98" | "1538.88" | "1538.78" | "1538.68" | "1538.58" | "1538.48" | "1538.38" | "1538.28" | "1538.19" | "1538.09" | "1537.99" | "1537.89" | "1537.79" | "1537.69" | "1537.59" | "1537.50" | "1537.40" | "1537.30" | "1537.20" | "1537.10" | "1537.00" | "1536.90" | "1536.81" | "1536.71" | "1536.61" | "1536.51" | "1536.41" | "1536.31" | "1536.22" | "1536.12" | "1536.02" | "1535.92" | "1535.82" | "1535.72" | "1535.63" | "1535.53" | "1535.43" | "1535.33" | "1535.23" | "1535.13" | "1535.04" | "1534.94" | "1534.84" | "1534.74" | "1534.64" | "1534.54" | "1534.45" | "1534.35" | "1534.25" | "1534.15" | "1534.05" | "1533.96" | "1533.86" | "1533.76" | "1533.66" | "1533.56" | "1533.47" | "1533.37" | "1533.27" | "1533.17" | "1533.07" | "1532.98" | "1532.88" | "1532.78" | "1532.68" | "1532.58" | "1532.49" | "1532.39" | "1532.29" | "1532.19" | "1532.09" | "1532.00" | "1531.90" | "1531.80" | "1531.70" | "1531.60" | "1531.51" | "1531.41" | "1531.31" | "1531.21" | "1531.12" | "1531.02" | "1530.92" | "1530.82" | "1530.72" | "1530.63" | "1530.53" | "1530.43" | "1530.33" | "1530.24" | "1530.14" | "1530.04" | "1529.94" | "1529.85" | "1529.75" | "1529.65" | "1529.55" | "1529.46" | "1529.36" | "1529.26" | "1529.16" | "1529.07" | "1528.97" | "1528.87" | "1528.77" | "1528.38")
                                        ),
                                        "tx-power" arg,
                                        "loopback",
                                        "los-warning-threshold" arg,
                                        "los-alarm-threshold" arg,
                                        "modulation-format" (
                                          ("16qam" | "8qam" | "qpsk")
                                        ),
                                        "laser-enable",
                                        "no-laser-enable",
                                        "is-ma",
                                        "no-is-ma",
                                        "encoding" (
                                          ("differential" | "non-differential")
                                        ),
                                        "fec" (
                                          ("sdfec" | "sdfec25")
                                        ),
                                        "alarm" (("low-light-alarm")) (
                                            c(
                                                c(
                                                  "syslog",
                                                  "link-down"
                                                )
                                            )
                                        ),
                                        "tca" (
                                            c(
                                                "tx-power-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tx-power-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "rx-power-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "rx-power-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "temperature-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "temperature-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "carrier-frequency-offset-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "carrier-frequency-offset-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "fec-ber" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ).as(:oneline),
                                                "tec-current-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "tec-current-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "residual-isi-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "residual-isi-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "pam-histogram-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "snr-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "fec-corrected-errors-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "fec-ucorrected-words-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "laser-frequency-error-high-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                ),
                                                "laser-frequency-error-low-tca" (
                                                    c(
                                                        "enable-tca",
                                                        "no-enable-tca",
                                                        "threshold" arg,
                                                        "threshold-24hrs" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "warning" (("low-light-warning")) (
                                            c(
                                                c(
                                                  "syslog",
                                                  "link-down"
                                                )
                                            )
                                        )
                                    )
                                ),
                                "otn-options" (
                                  otn_options_type
                                ),
                                "fastether-options" (
                                    c(
                                        "loopback",
                                        "no-loopback",
                                        "flow-control",
                                        "no-flow-control",
                                        "source-filtering",
                                        "no-source-filtering",
                                        "auto-negotiation",
                                        "no-auto-negotiation",
                                        "ingress-rate-limit" arg,
                                        "source-address-filter" arg.as(:oneline),
                                        "redundant-parent" (
                                            c(
                                                  interface_device
                                            )
                                        ),
                                        "ieee-802.3ad" (
                                            c(
                                                "lacp" (
                                                    c(
                                                        "port-priority" arg
                                                    )
                                                ),
                                                  interface_device,
                                                c(
                                                  "primary",
                                                  "backup"
                                                )
                                            )
                                        ),
                                        "mpls" (
                                          mpls_ifd_options
                                        ),
                                        "ignore-l3-incompletes"
                                    )
                                ),
                                "redundant-ether-options" (
                                    c(
                                        "redundancy-group" arg,
                                        "loopback",
                                        "no-loopback",
                                        "flow-control",
                                        "no-flow-control",
                                        "source-filtering",
                                        "no-source-filtering",
                                        "source-address-filter" arg.as(:oneline),
                                        "link-speed" (
                                          ("10m" | "100m" | "1g" | "10g")
                                        ),
                                        "minimum-links" arg,
                                        "lacp" (
                                            c(
                                                c(
                                                  "active",
                                                  "passive"
                                                ),
                                                "periodic" (
                                                  ("fast" | "slow")
                                                )
                                            )
                                        )
                                    )
                                ),
                                "aggregated-ether-options" (
                                    c(
                                        "loopback",
                                        "no-loopback",
                                        "flow-control",
                                        "no-flow-control",
                                        "source-filtering",
                                        "no-source-filtering",
                                        "autostate-exclude",
                                        "link-protection" (
                                            c(
                                                "revertive",
                                                "backup-state" (
                                                  ("accept-data" | "discard-data" | "down")
                                                )
                                            )
                                        ),
                                        "fcoe-lag",
                                        "no-fcoe-lag",
                                        "source-address-filter" arg.as(:oneline),
                                        "configured-flow-control" (
                                            c(
                                                "rx-buffers" (
                                                  ("on" | "off")
                                                ),
                                                "tx-buffers" (
                                                  ("on" | "off")
                                                )
                                            )
                                        ),
                                        "load-balance" (
                                          aggregate_load_balance
                                        ),
                                        "bfd-liveness-detection" (
                                            c(
                                                "version" (
                                                  ("0" | "1" | "automatic")
                                                ),
                                                "minimum-interval" arg,
                                                "minimum-transmit-interval" arg,
                                                "minimum-receive-interval" arg,
                                                "multiplier" arg,
                                                c(
                                                  "no-adaptation"
                                                ),
                                                "transmit-interval" (
                                                    c(
                                                        "minimum-interval" arg,
                                                        "threshold" arg
                                                    )
                                                ),
                                                "detection-time" (
                                                    c(
                                                        "threshold" arg
                                                    )
                                                ),
                                                "authentication" (
                                                    c(
                                                        "key-chain" arg,
                                                        "algorithm" (
                                                          ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                                        ),
                                                        "loose-check"
                                                    )
                                                ),
                                                "neighbor" (
                                                  ipaddr
                                                ),
                                                "local-address" (
                                                  ipaddr
                                                ),
                                                "holddown-interval" arg
                                            )
                                        ),
                                        "minimum-links" arg,
                                        "minimum-bandwidth" (
                                            c(
                                                "bw-value" arg,
                                                "bw-unit" (
                                                  ("bps" | "kbps" | "mbps" | "gbps")
                                                )
                                            )
                                        ),
                                        "targeted-options" (
                                            c(
                                                "type" (
                                                  ("auto" | "manual")
                                                ),
                                                c(
                                                  "logical-interface-fpc-redundancy",
                                                  "logical-interface-chassis-redundancy"
                                                ),
                                                "rebalance-periodic" (
                                                    c(
                                                        "start-time" (
                                                          time
                                                        ),
                                                        "interval" arg
                                                    )
                                                ),
                                                "rebalance-subscriber-granularity" arg
                                            )
                                        ),
                                        c(
                                          "logical-interface-fpc-redundancy",
                                          "logical-interface-chassis-redundancy"
                                        ),
                                        "rebalance-periodic" (
                                            c(
                                                "start-time" (
                                                  time
                                                ),
                                                "interval" arg
                                            )
                                        ),
                                        "pad-to-minimum-frame-size",
                                        "link-speed" (
                                          ("10m" | "100m" | "1g" | "8g" | "10g" | "25g" | "40g" | "50g" | "80g" | "100g" | "oc192" | "mixed")
                                        ),
                                        "local-bias" (
                                            c(
                                                "disable"
                                            )
                                        ),
                                        "local-minimum-links-threshold" arg,
                                        "resilient-hash",
                                        "lacp" (
                                            c(
                                                c(
                                                  "active",
                                                  "passive"
                                                ),
                                                "periodic" (
                                                  ("fast" | "slow")
                                                ),
                                                "fast-failover",
                                                "link-protection" (
                                                    c(
                                                        "disable",
                                                        c(
                                                          "revertive",
                                                          "non-revertive"
                                                        )
                                                    )
                                                ),
                                                "accept-data",
                                                "sync-reset" (
                                                  ("disable" | "enable")
                                                ),
                                                "system-priority" arg,
                                                "system-id" (
                                                  mac_addr
                                                ),
                                                "admin-key" arg,
                                                "hold-time" (
                                                    c(
                                                        "up" arg
                                                    )
                                                ).as(:oneline),
                                                "aggregate-wait-time" arg,
                                                "force-up"
                                            )
                                        ),
                                        "link-protection-sub-group" arg (
                                            c(
                                                c(
                                                  "primary",
                                                  "backup"
                                                )
                                            )
                                        ),
                                        "ethernet-switch-profile" (
                                            c(
                                                "tag-protocol-id" arg,
                                                "storm-control" (
                                                    c(
                                                        arg
                                                    )
                                                ),
                                                "mac-learn-enable"
                                            )
                                        ),
                                        "mc-ae" (
                                            c(
                                                "mc-ae-id" arg,
                                                "redundancy-group" arg,
                                                "chassis-id" arg,
                                                "mode" (
                                                  ("active-standby" | "active-active")
                                                ),
                                                "status-control" (
                                                  ("active" | "standby")
                                                ),
                                                "switchover-mode" (
                                                  ("revertive" | "non-revertive")
                                                ),
                                                "revert-time" arg,
                                                "init-delay-time" arg,
                                                "recovery-delay-time" arg,
                                                "enhanced-convergence",
                                                "events" (
                                                    c(
                                                        "iccp-peer-down" (
                                                            c(
                                                                "force-icl-down",
                                                                "prefer-status-control-active"
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "es-options" (
                                    c(
                                        "backup-interface" (
                                          interface_device
                                        )
                                    )
                                ),
                                "dsl-options" (
                                    c(
                                        "operating-mode" (
                                          ("auto" | "ansi-dmt" | "itu-dmt" | "etsi" | "itu-annexb-ur2" | "itu-annexb-non-ur2" | "itu-dmt-bis" | "adsl2plus" | "annexm-itu-dmt-bis" | "annexm-adsl2plus")
                                        )
                                    )
                                ),
                                "vdsl-options" (
                                    c(
                                        "vdsl-profile" (
                                          ("auto" | "8a" | "8b" | "8c" | "8d" | "12a" | "12b" | "17a")
                                        ),
                                        "sra" (
                                          ("enable" | "disable")
                                        ),
                                        "v43" (
                                          ("enable" | "disable")
                                        )
                                    )
                                ),
                                "shdsl-options" (
                                    c(
                                        "annex" (
                                          ("annex-a" | "annex-b" | "annex-f" | "annex-g" | "annex-auto")
                                        ),
                                        "line-rate" (
                                          ("auto" | arg)
                                        ),
                                        "loopback" (
                                          ("local" | "remote")
                                        ),
                                        "snr-margin" (
                                            c(
                                                "current" (
                                                  ("disable" | arg)
                                                ),
                                                "snext" (
                                                  ("disable" | arg)
                                                )
                                            )
                                        )
                                    )
                                ),
                                "data-input" (
                                    c(
                                        c(
                                          "system",
                                          "interface" (
                                            interface_device
                                          )
                                        )
                                    )
                                ),
                                "switch-options" (
                                    c(
                                        "switch-port" arg (
                                            c(
                                                "auto-negotiation",
                                                "no-auto-negotiation",
                                                "link-mode" (
                                                  ("half-duplex" | "full-duplex")
                                                ),
                                                "speed" (
                                                  ("10m" | "100m" | "1g")
                                                ),
                                                "vlan-id" arg,
                                                "cascade-port"
                                            )
                                        )
                                    )
                                ),
                                "container-options" (
                                    c(
                                        "container-type" (
                                            c(
                                                c(
                                                  "aps" (
                                                    aps_type
                                                  )
                                                )
                                            )
                                        ),
                                        "member-interface-type" (
                                            c(
                                                c(
                                                  "sonet" (
                                                      c(
                                                          "member-interface-speed" (
                                                            ("oc3" | "oc12" | "oc48" | "oc192" | "oc768" | "mixed")
                                                          )
                                                      )
                                                  ),
                                                  "atm" (
                                                      c(
                                                          "member-interface-speed" (
                                                            ("oc3" | "oc12" | "oc48")
                                                          )
                                                      )
                                                  ),
                                                  "channelized-sonet" (
                                                      c(
                                                          "member-interface-speed" (
                                                            ("coc3" | "coc12" | "coc48" | "coc192" | "coc768")
                                                          )
                                                      )
                                                  ),
                                                  "channelized-sdh" (
                                                      c(
                                                          "member-interface-speed" (
                                                            ("cstm1" | "cstm4" | "cstm16" | "coc64" | "cstm256")
                                                          )
                                                      )
                                                  )
                                                )
                                            )
                                        ),
                                        "redundancy" (
                                            c(
                                                "hold-time" (
                                                    c(
                                                        "up" arg,
                                                        "down" arg
                                                    )
                                                ).as(:oneline)
                                            )
                                        ),
                                        "container-list" (
                                          interface_device
                                        ),
                                        c(
                                            "primary",
                                            "standby"
                                        ),
                                        "fast-aps",
                                        "allow-configuration-override"
                                    )
                                ),
                                "layer2-policer" (
                                    c(
                                        c(
                                          "input-policer" arg,
                                          "input-hierarchical-policer" arg
                                        )
                                    )
                                ),
                                "unit" (("$junos-underlying-interface-unit" | "$junos-interface-unit" | arg)) (
                                    c(
                                        "policer-overhead" (
                                            c(
                                                  arg,
                                                "ingress" arg,
                                                "egress" arg
                                            )
                                        ),
                                        "alias" arg,
                                        "enhanced-convergence",
                                        "proxy-macip-advertisement",
                                        "peer-psd" (
                                            c(
                                                arg
                                            )
                                        ).as(:oneline),
                                        "peer-interface" (
                                            c(
                                                  interface_unit
                                            )
                                        ),
                                        "interface-shared-with" (
                                            c(
                                                arg
                                            )
                                        ),
                                          ("disable"),
                                        "passive-monitor-mode",
                                        "per-session-scheduler",
                                        "account-layer2-overhead" (
                                            c(
                                                  arg,
                                                "ingress" arg,
                                                "egress" arg
                                            )
                                        ),
                                        "forwarding-class-accounting" (
                                            c(
                                                "direction" (
                                                  ("ingress" | "egress" | "both")
                                                ),
                                                "enhanced" (
                                                    c(
                                                        "traffic-type" (
                                                          ("unicast-statistics" | "multicast-statistics")
                                                        ),
                                                        "family" (
                                                          ("inet" | "inet6" | "both")
                                                        ),
                                                        "direction" (
                                                          ("ingress" | "egress" | "both")
                                                        ),
                                                        "overhead-bytes" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "clear-dont-fragment-bit",
                                        "packet-inject-enable",
                                        "reassemble-packets",
                                        "services-options",
                                        "rpm" (
                                            c(
                                                c(
                                                  c(
                                                    "client",
                                                    "server"
                                                  ),
                                                  "twamp-server",
                                                  "twamp-client"
                                                )
                                            )
                                        ),
                                        "description" arg,
                                        "metadata" arg,
                                        "dial-options" (
                                            c(
                                                c(
                                                  "l2tp-interface-id" arg,
                                                  "ipsec-interface-id" arg
                                                ),
                                                c(
                                                  "dedicated",
                                                  "shared"
                                                )
                                            )
                                        ),
                                        "actual-transit-statistics",
                                        "demux-source" (
                                              (("inet" | "inet6"))
                                        ),
                                        "demux-destination" (
                                              (("inet" | "inet6"))
                                        ),
                                        "encapsulation" (
                                          ("atm-nlpid" | "atm-cisco-nlpid" | "atm-snap" | "atm-vc-mux" | "atm-ccc-vc-mux" | "atm-tcc-vc-mux" | "atm-tcc-snap" | "atm-ccc-cell-relay" | "vlan-vci-ccc" | "ether-over-atm-llc" | "ether-vpls-over-atm-llc" | "ppp-over-ether-over-atm-llc" | "ppp-over-ether" | "atm-ppp-vc-mux" | "atm-ppp-llc" | "atm-mlppp-llc" | "frame-relay-ppp" | "frame-relay-ccc" | "frame-relay" | "frame-relay-tcc" | "frame-relay-ether-type" | "frame-relay-ether-type-tcc" | "ether-vpls-fr" | "vlan-ccc" | "ethernet-ccc" | "vlan-vpls" | "vlan-bridge" | "dix" | "ethernet" | "ethernet-vpls" | "ethernet-bridge" | "vlan" | "vlan-tcc" | "multilink-ppp" | "multilink-frame-relay-end-to-end" | "ppp-ccc")
                                        ),
                                        "gre",
                                        "mtu" arg,
                                        c(
                                          "point-to-point",
                                          "multipoint"
                                        ),
                                        "bandwidth" arg,
                                        "global-layer2-domainid" arg,
                                        "radio-router" (
                                          dynamic_ifbw_parms_type
                                        ),
                                        "traps",
                                        "no-traps",
                                        "routing-services",
                                        "no-routing-services",
                                        "arp-resp" (
                                            c(
                                                c(
                                                  "unrestricted",
                                                  "restricted"
                                                )
                                            )
                                        ).as(:oneline),
                                        "proxy-arp" (
                                            c(
                                                c(
                                                  "unrestricted",
                                                  "restricted"
                                                )
                                            )
                                        ).as(:oneline),
                                        c(
                                          "vlan-id" (
                                            ("none" | arg)
                                          ),
                                          "vlan-id-range" arg,
                                          "inner-vlan-id-swap-ranges" arg,
                                          "vlan-id-list" arg,
                                          "vlan-tag" arg,
                                          "vlan-tags" (
                                              c(
                                                  "outer" (
                                                    ("$junos-stacked-vlan-id" | "$junos-vlan-id" | arg)
                                                  ),
                                                  c(
                                                    "inner" (
                                                      ("$junos-vlan-id" | arg)
                                                    ),
                                                    "inner-range" arg,
                                                    "inner-list" arg
                                                  )
                                              )
                                          ).as(:oneline)
                                        ),
                                        "native-inner-vlan-id" arg,
                                        "inner-vlan-id-range" (
                                            c(
                                                "start" arg,
                                                "end" arg
                                            )
                                        ).as(:oneline),
                                        "accept-source-mac" (
                                            c(
                                                "mac-address" (
                                                  mac_list
                                                )
                                            )
                                        ),
                                        "input-vlan-map" (
                                          vlan_map
                                        ),
                                        "output-vlan-map" (
                                          vlan_map
                                        ),
                                        "swap-by-poppush",
                                        "receive-lsp" arg,
                                        "transmit-lsp" arg,
                                        "dlci" arg,
                                        "multicast-dlci" arg,
                                        c(
                                          "vci" (
                                            atm_vci
                                          ),
                                          "allow-any-vci",
                                          "vpi" arg,
                                          "trunk-id" arg
                                        ),
                                        "no-vpivci-swapping",
                                        c(
                                          "psn-vci" (
                                            atm_vci
                                          ),
                                          "psn-vpi" arg
                                        ),
                                        "atm-l2circuit-mode" (
                                            c(
                                                c(
                                                  "cell",
                                                  "aal5"
                                                )
                                            )
                                        ).as(:oneline),
                                        "vci-range" (
                                            c(
                                                "start" arg,
                                                "end" arg
                                            )
                                        ).as(:oneline),
                                        "trunk-bandwidth" arg,
                                        "multicast-vci" (
                                          atm_vci
                                        ),
                                        "shaping" (
                                          dcd_shaping_config
                                        ),
                                        "oam-period" (
                                            c(
                                                c(
                                                    arg,
                                                  "disable".as(:oneline)
                                                )
                                            )
                                        ).as(:oneline),
                                        "oam-liveness" (
                                            c(
                                                "up-count" arg,
                                                "down-count" arg
                                            )
                                        ),
                                        "ppp-options" (
                                          ppp_options_type
                                        ),
                                        "pppoe-options" (
                                          pppoe_options_type
                                        ),
                                        "pppoe-underlying-options" (
                                          pppoe_underlying_options_type
                                        ),
                                        "advisory-options" (
                                          advisory_options_type
                                        ),
                                        "auto-configure" (
                                          auto_configure_vlan_type
                                        ),
                                        "demux-options" (
                                          demux_options_type
                                        ),
                                        "targeted-distribution" (
                                            c(
                                                "primary-list" arg,
                                                "backup-list" arg,
                                                "standby-list" arg
                                            )
                                        ),
                                        "targeted-options" (
                                            c(
                                                "primary" (
                                                  interface_device
                                                ),
                                                "backup" (
                                                  interface_device
                                                ),
                                                "group" arg
                                            )
                                        ),
                                        c(
                                          "keepalives" (
                                            keepalives_type
                                          ).as(:oneline),
                                          "no-keepalives"
                                        ),
                                        "inverse-arp",
                                        "transmit-weight" arg,
                                        "epd-threshold" (
                                          epd_threshold_config
                                        ).as(:oneline),
                                        "cell-bundle-size" arg,
                                        "cell-bundle-timeout" arg,
                                        "plp-to-clp",
                                        "atm-scheduler-map" arg,
                                        "mrru" arg,
                                        "short-sequence",
                                        "fragment-threshold" arg,
                                        "drop-timeout" arg,
                                        "disable-mlppp-inner-ppp-pfc",
                                        "minimum-links" arg,
                                        "multilink-max-classes" arg,
                                        "compression" (
                                            c(
                                                "rtp" (
                                                    c(
                                                        "f-max-period" arg,
                                                        "queues" (
                                                          ("q0" | "q1" | "q2" | "q3")
                                                        ),
                                                        "port" (
                                                            c(
                                                                "minimum" arg,
                                                                "maximum" arg
                                                            )
                                                        ).as(:oneline),
                                                        "maximum-contexts" (
                                                            c(
                                                                  arg
                                                            )
                                                        ).as(:oneline)
                                                    )
                                                )
                                            )
                                        ),
                                        "interleave-fragments",
                                        "link-layer-overhead" (
                                          unsigned_float
                                        ),
                                        "accounting-profile" arg,
                                        "peer-unit" arg,
                                        "tunnel" (
                                            c(
                                                "source" (
                                                  ipaddr
                                                ),
                                                "destination" (
                                                  ipaddr
                                                ),
                                                "key" arg,
                                                "backup-destination" (
                                                  ipaddr
                                                ),
                                                c(
                                                  "allow-fragmentation",
                                                  "do-not-fragment"
                                                ),
                                                "ttl" arg,
                                                "traffic-class" arg,
                                                "flow-label" arg,
                                                "path-mtu-discovery",
                                                "no-path-mtu-discovery",
                                                "routing-instance" (
                                                    c(
                                                        "destination" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "compression-device" (
                                          interface_unit
                                        ),
                                        "atm-policer" (
                                            c(
                                                "input-atm-policer" arg
                                            )
                                        ),
                                        "layer2-policer" (
                                            c(
                                                c(
                                                  "input-policer" arg,
                                                  "input-hierarchical-policer" arg,
                                                  "input-three-color" arg
                                                ),
                                                c(
                                                  "output-policer" (
                                                    ("$junos-layer2-output-policer" | arg)
                                                  ),
                                                  "output-three-color" (
                                                    ("$junos-layer2-output-policer" | arg)
                                                  )
                                                )
                                            )
                                        ),
                                        "filter" (
                                            c(
                                                c(
                                                  "input" (
                                                      c(
                                                          arg,
                                                          "shared-name" arg,
                                                          "precedence" arg
                                                      )
                                                  ).as(:oneline)
                                                ),
                                                c(
                                                  "output" (
                                                      c(
                                                          arg,
                                                          "shared-name" arg,
                                                          "precedence" arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ),
                                        "multi-chassis-protection" (
                                          multi_chassis_protection_group_ifl
                                        ),
                                        "statistics",
                                        "esi" (
                                            c(
                                                  esi,
                                                c(
                                                  "single-active",
                                                  "all-active"
                                                )
                                            )
                                        ),
                                        "virtual-gateway-esi" (
                                            c(
                                                  esi,
                                                c(
                                                  "single-active",
                                                  "all-active"
                                                )
                                            )
                                        ),
                                        "service" (
                                            c(
                                                "pcef" arg (
                                                    c(
                                                        "activate-all",
                                                        "activate" arg
                                                    )
                                                )
                                            )
                                        ),
                                        "family" (
                                            c(
                                                "inet" (
                                                    c(
                                                        "dhcp" (
                                                          dhcp_client_type
                                                        ),
                                                        "targeted-broadcast" (
                                                            c(
                                                                c(
                                                                  "forward-and-send-to-re",
                                                                  "forward-only"
                                                                )
                                                            )
                                                        ),
                                                        "destination-class-usage",
                                                        "transit-options-packets",
                                                        "transit-ttl-exceeded",
                                                        "receive-options-packets",
                                                        "receive-ttl-exceeded",
                                                        "accounting" (
                                                            c(
                                                                "source-class-usage" (
                                                                    c(
                                                                        "input",
                                                                        "output"
                                                                    )
                                                                ),
                                                                "destination-class-usage"
                                                            )
                                                        ),
                                                        "mac-validate" (
                                                          ("strict" | "loose")
                                                        ),
                                                        "rpf-check" (
                                                            c(
                                                                "fail-filter" arg,
                                                                "mode" (
                                                                    c(
                                                                        "loose"
                                                                    )
                                                                ).as(:oneline)
                                                            )
                                                        ),
                                                        "mtu" arg,
                                                        "arp-max-cache" arg,
                                                        "arp-new-hold-limit" arg,
                                                        "tcp-mss" arg,
                                                        "no-redirects",
                                                        "no-neighbor-learn",
                                                        "unconditional-src-learn",
                                                        "multicast-only",
                                                        "primary",
                                                        "ipsec-sa" arg,
                                                        "allow-filter-on-re",
                                                        "demux-source" ("$junos-subscriber-ip-address" | arg),
                                                        "demux-destination" ("$junos-subscriber-ip-address" | arg),
                                                        "filter" (
                                                            c(
                                                                c(
                                                                  "input" (
                                                                      c(
                                                                          arg,
                                                                          "shared-name" arg,
                                                                          "precedence" arg
                                                                      )
                                                                  ).as(:oneline),
                                                                  "input-list" arg
                                                                ),
                                                                c(
                                                                  "output" (
                                                                      c(
                                                                          arg,
                                                                          "shared-name" arg,
                                                                          "precedence" arg
                                                                      )
                                                                  ).as(:oneline),
                                                                  "output-list" arg
                                                                ),
                                                                "adf" (
                                                                    c(
                                                                        "rule" arg,
                                                                        "counter",
                                                                        "input-precedence" arg,
                                                                        "not-mandatory",
                                                                        "output-precedence" arg
                                                                    )
                                                                ),
                                                                "group" arg
                                                            )
                                                        ),
                                                        "ingress-queuing-filter" (
                                                            c(
                                                                arg
                                                            )
                                                        ).as(:oneline),
                                                        "simple-filter" (
                                                            c(
                                                                "input" arg
                                                            )
                                                        ),
                                                        "input-hierarchical-policer" arg,
                                                        "policer" (
                                                            c(
                                                                "arp" arg,
                                                                "input" arg,
                                                                "output" arg
                                                            )
                                                        ),
                                                        "sampling" (
                                                            c(
                                                                "input",
                                                                "output"
                                                            )
                                                        ),
                                                        "service" (
                                                            c(
                                                                "input" (
                                                                    c(
                                                                        "service-set" arg (
                                                                            c(
                                                                                "service-filter" arg
                                                                            )
                                                                        ),
                                                                        "post-service-filter" arg
                                                                    )
                                                                ),
                                                                "output" (
                                                                    c(
                                                                        "service-set" arg (
                                                                            c(
                                                                                "service-filter" arg
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        ),
                                                        "next-hop-tunnel" arg (
                                                            c(
                                                                "ipsec-vpn" arg
                                                            )
                                                        ),
                                                        "address" arg (
                                                            c(
                                                                "destination" (
                                                                  ipv4addr
                                                                ),
                                                                "destination-profile" arg,
                                                                "broadcast" (
                                                                  ipv4addr
                                                                ),
                                                                "primary",
                                                                "preferred",
                                                                "master-only",
                                                                "multipoint-destination" arg (
                                                                    c(
                                                                        c(
                                                                          "dlci" arg,
                                                                          "vci" (
                                                                            atm_vci
                                                                          )
                                                                        ),
                                                                        "shaping" (
                                                                          dcd_shaping_config
                                                                        ),
                                                                        "oam-period" (
                                                                            c(
                                                                                c(
                                                                                    arg,
                                                                                  "disable".as(:oneline)
                                                                                )
                                                                            )
                                                                        ).as(:oneline),
                                                                        "oam-liveness" (
                                                                            c(
                                                                                "up-count" arg,
                                                                                "down-count" arg
                                                                            )
                                                                        ),
                                                                        "inverse-arp",
                                                                        "transmit-weight" arg,
                                                                        "epd-threshold" (
                                                                          epd_threshold_config
                                                                        ).as(:oneline)
                                                                    )
                                                                ),
                                                                "arp" arg (
                                                                    c(
                                                                        "l2-interface" (
                                                                          interface_name
                                                                        ),
                                                                        c(
                                                                          "mac" (
                                                                            mac_unicast
                                                                          ),
                                                                          "multicast-mac" (
                                                                            mac_multicast
                                                                          )
                                                                        ),
                                                                        "publish"
                                                                    )
                                                                ).as(:oneline),
                                                                "web-authentication" (
                                                                    c(
                                                                        "http",
                                                                        "https",
                                                                        "redirect-to-https"
                                                                    )
                                                                ),
                                                                "vrrp-group" (
                                                                  vrrp_group
                                                                ),
                                                                "virtual-gateway-address" (
                                                                  ipv4addr
                                                                )
                                                            )
                                                        ),
                                                        "unnumbered-address" (
                                                            c(
                                                                  interface_unit,
                                                                "preferred-source-address" (
                                                                  ("$junos-preferred-source-address" | arg)
                                                                ),
                                                                "destination" (
                                                                  ipv4addr
                                                                ),
                                                                "destination-profile" arg
                                                            )
                                                        ).as(:oneline),
                                                        "location-pool-address" (
                                                            c(
                                                                  arg
                                                            )
                                                        ),
                                                        "negotiate-address"
                                                    )
                                                ),
                                                "iso" (
                                                    c(
                                                        "address" arg,
                                                        "mtu" arg
                                                    )
                                                ),
                                                "inet6" (
                                                    c(
                                                        "dhcpv6-client" (
                                                            c(
                                                                "client-type" (
                                                                  ("stateful" | "autoconfig")
                                                                ),
                                                                "client-ia-type" (("ia-na" | "ia-pd")),
                                                                "rapid-commit",
                                                                "client-identifier" (
                                                                    c(
                                                                        "duid-type" (
                                                                          ("duid-llt" | "vendor" | "duid-ll")
                                                                        )
                                                                    )
                                                                ).as(:oneline),
                                                                "req-option" (("dns-server" | "domain" | "ntp-server" | "time-zone" | "sip-server" | "sip-domain" | "nis-server" | "nis-domain" | "fqdn" | "vendor-spec")),
                                                                "retransmission-attempt" arg,
                                                                "no-dns-propagation",
                                                                "update-router-advertisement" (
                                                                    c(
                                                                        "interface" arg (
                                                                            c(
                                                                                "managed-configuration",
                                                                                "no-managed-configuration",
                                                                                "other-stateful-configuration",
                                                                                "no-other-stateful-configuration",
                                                                                "max-advertisement-interval" arg,
                                                                                "min-advertisement-interval" arg
                                                                            )
                                                                        )
                                                                    )
                                                                ),
                                                                "update-server"
                                                            )
                                                        ),
                                                        "rpf-check" (
                                                            c(
                                                                "fail-filter" arg,
                                                                "mode" (
                                                                    c(
                                                                        "loose"
                                                                    )
                                                                ).as(:oneline)
                                                            )
                                                        ),
                                                        "accounting" (
                                                            c(
                                                                "source-class-usage" (
                                                                    c(
                                                                        "input",
                                                                        "output"
                                                                    )
                                                                ),
                                                                "destination-class-usage"
                                                            )
                                                        ),
                                                        "mtu" arg,
                                                        "tcp-mss" arg,
                                                        "nd6-stale-time" arg,
                                                        "no-neighbor-learn",
                                                        "nd6-max-cache" arg,
                                                        "nd6-new-hold-limit" arg,
                                                        "no-redirects",
                                                        "allow-filter-on-re",
                                                        "filter" (
                                                            c(
                                                                c(
                                                                  "input" (
                                                                      c(
                                                                          arg,
                                                                          "shared-name" arg,
                                                                          "precedence" arg
                                                                      )
                                                                  ).as(:oneline),
                                                                  "input-list" arg
                                                                ),
                                                                c(
                                                                  "output" (
                                                                      c(
                                                                          arg,
                                                                          "shared-name" arg,
                                                                          "precedence" arg
                                                                      )
                                                                  ).as(:oneline),
                                                                  "output-list" arg
                                                                ),
                                                                "adf" (
                                                                    c(
                                                                        "rule" arg,
                                                                        "counter",
                                                                        "input-precedence" arg,
                                                                        "not-mandatory",
                                                                        "output-precedence" arg
                                                                    )
                                                                ),
                                                                "group" arg
                                                            )
                                                        ),
                                                        "ingress-queuing-filter" (
                                                            c(
                                                                arg
                                                            )
                                                        ).as(:oneline),
                                                        "input-hierarchical-policer" arg,
                                                        "policer" (
                                                            c(
                                                                "input" arg,
                                                                "output" arg
                                                            )
                                                        ),
                                                        "sampling" (
                                                            c(
                                                                "input",
                                                                "output"
                                                            )
                                                        ),
                                                        "service" (
                                                            c(
                                                                "input" (
                                                                    c(
                                                                        "service-set" arg (
                                                                            c(
                                                                                "service-filter" arg
                                                                            )
                                                                        ),
                                                                        "post-service-filter" arg
                                                                    )
                                                                ),
                                                                "output" (
                                                                    c(
                                                                        "service-set" arg (
                                                                            c(
                                                                                "service-filter" arg
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        ),
                                                        "address" arg (
                                                            c(
                                                                "destination" (
                                                                  ipv6addr
                                                                ),
                                                                "eui-64",
                                                                "primary",
                                                                "preferred",
                                                                "master-only",
                                                                "ndp" arg (
                                                                    c(
                                                                        "l2-interface" (
                                                                          interface_name
                                                                        ),
                                                                        c(
                                                                          "mac" (
                                                                            mac_unicast
                                                                          ),
                                                                          "multicast-mac" (
                                                                            mac_multicast
                                                                          )
                                                                        ),
                                                                        "publish"
                                                                    )
                                                                ).as(:oneline),
                                                                "vrrp-inet6-group" (
                                                                  vrrp_group
                                                                ),
                                                                "web-authentication" (
                                                                    c(
                                                                        "http",
                                                                        "https",
                                                                        "redirect-to-https"
                                                                    )
                                                                ),
                                                                "virtual-gateway-address" (
                                                                  ipv6addr
                                                                ),
                                                                "subnet-router-anycast"
                                                            )
                                                        ),
                                                        "demux-source" ("$junos-subscriber-ipv6-address" | arg | "$junos-subscriber-ipv6-multi-address"),
                                                        "demux-destination" ("$junos-subscriber-ipv6-address" | arg),
                                                        "unnumbered-address" (
                                                            c(
                                                                  interface_unit,
                                                                "preferred-source-address" (
                                                                  ("$junos-preferred-source-ipv6-address" | arg)
                                                                )
                                                            )
                                                        ).as(:oneline),
                                                        "dad-disable",
                                                        "no-dad-disable"
                                                    )
                                                ),
                                                "mpls" (
                                                    c(
                                                        "mtu" arg,
                                                        "maximum-labels" arg,
                                                        "filter" (
                                                            c(
                                                                c(
                                                                  "input" arg,
                                                                  "input-list" arg
                                                                ),
                                                                c(
                                                                  "output" arg,
                                                                  "output-list" arg
                                                                ),
                                                                "group" arg
                                                            )
                                                        ),
                                                        "ingress-queuing-filter" (
                                                            c(
                                                                arg
                                                            )
                                                        ).as(:oneline),
                                                        "input-hierarchical-policer" arg,
                                                        "policer" (
                                                            c(
                                                                "input" arg,
                                                                "output" arg
                                                            )
                                                        )
                                                    )
                                                ),
                                                "mlppp" (
                                                    c(
                                                        "bundle" (
                                                          ("$junos-bundle-interface-name" | arg)
                                                        ),
                                                        c(
                                                          "service-interface" (
                                                            interface_device
                                                          ),
                                                          "service-device-pool" arg
                                                        ),
                                                        "dynamic-profile" arg
                                                    )
                                                ),
                                                "mlfr-end-to-end" (
                                                    c(
                                                        "bundle" (
                                                          interface_unit
                                                        )
                                                    )
                                                ),
                                                "mlfr-uni-nni" (
                                                    c(
                                                        "bundle" (
                                                          interface_unit
                                                        )
                                                    )
                                                ),
                                                "ccc" (
                                                    c(
                                                        "mtu" arg,
                                                        "filter" (
                                                            c(
                                                                c(
                                                                  "input" arg,
                                                                  "input-list" arg
                                                                ),
                                                                c(
                                                                  "output" arg,
                                                                  "output-list" arg
                                                                ),
                                                                "group" arg
                                                            )
                                                        ),
                                                        "ingress-queuing-filter" (
                                                            c(
                                                                arg
                                                            )
                                                        ).as(:oneline),
                                                        "policer" (
                                                            c(
                                                                "input" arg,
                                                                "output" arg
                                                            )
                                                        ),
                                                        "translate-fecn-and-becn",
                                                        c(
                                                          "translate-discard-eligible",
                                                          "translate-plp-control-word-de"
                                                        ),
                                                        "keep-address-and-control"
                                                    )
                                                ),
                                                "tcc" (
                                                    c(
                                                        "policer" (
                                                            c(
                                                                "input" arg,
                                                                "output" arg
                                                            )
                                                        ),
                                                        "proxy" (
                                                            c(
                                                                "inet-address" (
                                                                  ipv4addr
                                                                )
                                                            )
                                                        ),
                                                        "remote" (
                                                            c(
                                                                "inet-address" (
                                                                  ipv4addr
                                                                ),
                                                                "mac-address" (
                                                                  mac_addr
                                                                )
                                                            )
                                                        ),
                                                        "protocols" (
                                                          ("mpls" | "inet" | "iso")
                                                        )
                                                    )
                                                ),
                                                "vpls" (
                                                    c(
                                                        "core-facing",
                                                        "filter" (
                                                            c(
                                                                c(
                                                                  "input" (
                                                                      c(
                                                                          arg,
                                                                          "shared-name" arg,
                                                                          "precedence" arg
                                                                      )
                                                                  ).as(:oneline),
                                                                  "input-list" arg
                                                                ),
                                                                c(
                                                                  "output" (
                                                                      c(
                                                                          arg,
                                                                          "shared-name" arg,
                                                                          "precedence" arg
                                                                      )
                                                                  ).as(:oneline),
                                                                  "output-list" arg
                                                                ),
                                                                "adf" (
                                                                    c(
                                                                        "rule" arg,
                                                                        "counter",
                                                                        "input-precedence" arg,
                                                                        "not-mandatory",
                                                                        "output-precedence" arg
                                                                    )
                                                                ),
                                                                "group" arg
                                                            )
                                                        ),
                                                        "ingress-queuing-filter" (
                                                            c(
                                                                arg
                                                            )
                                                        ).as(:oneline),
                                                        "policer" (
                                                            c(
                                                                "input" arg,
                                                                "output" arg
                                                            )
                                                        )
                                                    )
                                                ),
                                                "bridge" (
                                                    c(
                                                        "core-facing",
                                                        "filter" (
                                                            c(
                                                                c(
                                                                  "input" (
                                                                      c(
                                                                          arg,
                                                                          "shared-name" arg,
                                                                          "precedence" arg
                                                                      )
                                                                  ).as(:oneline),
                                                                  "input-list" arg
                                                                ),
                                                                c(
                                                                  "output" (
                                                                      c(
                                                                          arg,
                                                                          "shared-name" arg,
                                                                          "precedence" arg
                                                                      )
                                                                  ).as(:oneline),
                                                                  "output-list" arg
                                                                ),
                                                                "adf" (
                                                                    c(
                                                                        "rule" arg,
                                                                        "counter",
                                                                        "input-precedence" arg,
                                                                        "not-mandatory",
                                                                        "output-precedence" arg
                                                                    )
                                                                ),
                                                                "group" arg
                                                            )
                                                        ),
                                                        "ingress-queuing-filter" (
                                                            c(
                                                                arg
                                                            )
                                                        ).as(:oneline),
                                                        "policer" (
                                                            c(
                                                                "input" arg,
                                                                "output" arg
                                                            )
                                                        ),
                                                        "interface-mode" (
                                                          ("access" | "trunk")
                                                        ),
                                                        "vlan-auto-sense",
                                                        "bridge-domain-type" (
                                                          ("svlan" | "bvlan")
                                                        ),
                                                        "inter-switch-link",
                                                        c(
                                                          "vlan-id" arg,
                                                          "vlan-id-list" arg,
                                                          "inner-vlan-id-list" arg
                                                        ),
                                                        "vlan-rewrite" (
                                                            c(
                                                                "translate" arg (
                                                                    c(
                                                                          arg
                                                                    )
                                                                ).as(:oneline)
                                                            )
                                                        ),
                                                        c(
                                                          "isid-list" (
                                                            ("all-service-groups" | "all")
                                                          )
                                                        ),
                                                        "storm-control" (
                                                            c(
                                                                arg
                                                            )
                                                        ),
                                                        "recovery-timeout" (
                                                            c(
                                                                  arg
                                                            )
                                                        ).as(:oneline)
                                                    )
                                                ),
                                                "ethernet-switching" (
                                                  ethernet_switching_type
                                                ),
                                                "fibre-channel" (
                                                  fibre_channel_type
                                                ),
                                                "pppoe" (
                                                  pppoe_underlying_options_type
                                                ),
                                                "any" (
                                                    c(
                                                        "filter" (
                                                            c(
                                                                "input" arg,
                                                                "group" arg
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        ),
                                        "service-domain" (
                                          ("inside" | "outside")
                                        ),
                                        "copy-tos-to-outer-ip-header",
                                        "copy-tos-to-outer-ip-header-transit",
                                        "load-balancing-options" (
                                            c(
                                                "preferred-active" (
                                                  interface_device
                                                ),
                                                "hash-keys" (
                                                    c(
                                                        "ingress-key" (
                                                              (("source-ip" | "destination-ip" | "protocol" | "iif"))
                                                        ),
                                                        "egress-key" (
                                                              (("source-ip" | "destination-ip" | "protocol" | "oif"))
                                                        )
                                                    )
                                                )
                                            )
                                        ),
                                        "mac" (
                                          mac_unicast
                                        ),
                                        "virtual-gateway-v4-mac" (
                                          mac_unicast
                                        ),
                                        "virtual-gateway-v6-mac" (
                                          mac_unicast
                                        ),
                                        "forwarding-options" (
                                            c(
                                                "load-balance-stateful" (
                                                    c(
                                                        "per-flow",
                                                        "rebalance" arg,
                                                        "load-type" (
                                                          ("high" | "medium" | "low")
                                                        )
                                                    )
                                                )
                                            )
                                        ),
                                        "etree-ac-role" (
                                          ("root" | "leaf")
                                        )
                                    )
                                ),
                                "no-partition" (
                                    c(
                                        "interface-type" (
                                          ("e1" | "t1" | "at" | "t3" | "e3" | "ct3" | "so" | "cau4")
                                        )
                                    )
                                ).as(:oneline),
                                "partition" arg (
                                    c(
                                        "oc-slice" arg,
                                        "timeslots" arg,
                                        "interface-type" (
                                          ("ds" | "e1" | "t1" | "at" | "ct1" | "ce1" | "t3" | "ct3" | "e3" | "so" | "coc1" | "cau4" | "dc" | "bc")
                                        )
                                    )
                                ).as(:oneline),
                                "radius-options" (
                                  radius_options_vlan_type
                                )
                            )
                        ),
                          interfaces_type
                    )
                )
            )
        ),
        "protocols" (
            c(
                "igmp" (
                    c(
                        "traceoptions" (
                            c(
                                "file" (
                                  trace_file_type
                                ),
                                "flag" (("packets" | "query" | "report" | "leave" | "mtrace" | "group" | "client-notification" | "host-notification" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                                    c(
                                        "send",
                                        "receive",
                                        "detail",
                                        "disable"
                                    )
                                ).as(:oneline)
                            )
                        ),
                        "query-interval" arg,
                        "query-response-interval" arg,
                        "query-last-member-interval" arg,
                        "robust-count" arg,
                        "maximum-transmit-rate" arg,
                        "accounting",
                        "interface" ("$junos-interface-name" | arg) (
                            c(
                                  ("disable"),
                                "version" arg,
                                "static" (
                                    c(
                                        "group" arg (
                                            c(
                                                "group-increment" (
                                                  ipv4addr
                                                ),
                                                "group-count" arg,
                                                "exclude",
                                                "source" arg (
                                                    c(
                                                        "source-increment" (
                                                          ipv4addr
                                                        ),
                                                        "source-count" arg
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "ssm-map" arg,
                                "ssm-map-policy" (
                                  policy_algebra
                                ),
                                "immediate-leave",
                                "promiscuous-mode",
                                "accounting",
                                "no-accounting",
                                "group-policy" (
                                  policy_algebra
                                ),
                                "group-limit" arg,
                                "group-threshold" arg,
                                "log-interval" arg,
                                "passive" (
                                    c(
                                        "allow-receive",
                                        "send-general-query",
                                        "send-group-query"
                                    )
                                ).as(:oneline),
                                "oif-map" (
                                  policy_algebra
                                ),
                                "distributed"
                            )
                        ),
                        "amt" (
                            c(
                                "relay" (
                                    c(
                                        "defaults" (
                                            c(
                                                "version" arg,
                                                "ssm-map" arg,
                                                "ssm-map-policy" (
                                                  policy_algebra
                                                ),
                                                "accounting",
                                                "no-accounting",
                                                "group-policy" (
                                                  policy_algebra
                                                ),
                                                "group-limit" arg,
                                                "group-threshold" arg,
                                                "log-interval" arg,
                                                "robust-count" arg,
                                                "query-interval" arg,
                                                "query-response-interval" arg
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                ),
                "oam" (
                    c(
                        "ethernet" (
                            c(
                                "link-fault-management" (
                                    c(
                                        "traceoptions" (
                                            c(
                                                "no-remote-trace",
                                                "file" (
                                                    c(
                                                          arg,
                                                        "size" arg,
                                                        "files" arg,
                                                        "world-readable",
                                                        "no-world-readable",
                                                        "match" (
                                                          regular_expression
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "flag" (("configuration" | "routing-socket" | "protocol" | "action-profile" | "all")).as(:oneline)
                                            )
                                        ),
                                        "action-profile" arg (
                                            c(
                                                "event" (
                                                    c(
                                                        "link-adjacency-loss",
                                                        "protocol-down",
                                                        "link-event-rate" (
                                                            c(
                                                                "symbol-period" arg,
                                                                "frame-error" arg,
                                                                "frame-period" arg,
                                                                "frame-period-summary" arg
                                                            )
                                                        )
                                                    )
                                                ),
                                                "action" (
                                                    c(
                                                        "syslog",
                                                        "link-down",
                                                        "send-critical-event"
                                                    )
                                                )
                                            )
                                        ),
                                        "interface" arg (
                                            c(
                                                "apply-action-profile" arg,
                                                "pdu-interval" arg,
                                                "loopback-tracking",
                                                "detect-loc",
                                                "link-discovery" (
                                                  ("active" | "passive")
                                                ),
                                                "pdu-threshold" arg,
                                                "remote-loopback",
                                                "negotiation-options" (
                                                    c(
                                                        "no-allow-link-events",
                                                        "allow-remote-loopback"
                                                    )
                                                ),
                                                "event-thresholds" (
                                                    c(
                                                        "symbol-period" arg,
                                                        "frame-error" arg,
                                                        "frame-period" arg,
                                                        "frame-period-summary" arg
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "connectivity-fault-management" (
                                    c(
                                        "performance-monitoring" (
                                            c(
                                                "hardware-assisted-timestamping",
                                                "delegate-server-processing",
                                                "hardware-assisted-keepalives" (
                                                  ("enable" | "disable")
                                                ),
                                                "enhanced-sla-iterator",
                                                "measurement-interval" (
                                                  ("2" | "5" | "15" | "30" | "60")
                                                ),
                                                "sla-iterator-profiles" arg (
                                                    c(
                                                        "disable",
                                                        "measurement-type" (
                                                          ("two-way-delay" | "loss" | "slm" | "statistical-frame-loss")
                                                        ),
                                                        "flap-trap-monitor" arg,
                                                        "cycle-time" arg,
                                                        "iteration-period" arg,
                                                        "calculation-weight" (
                                                            c(
                                                                "delay" arg,
                                                                "delay-variation" arg
                                                            )
                                                        ),
                                                        "avg-flr-forward-threshold" (
                                                            c(
                                                                  arg,
                                                                "flap-trap-monitor" arg
                                                            )
                                                        ),
                                                        "avg-flr-backward-threshold" (
                                                            c(
                                                                  arg,
                                                                "flap-trap-monitor" arg
                                                            )
                                                        ),
                                                        "avg-fd-twoway-threshold" (
                                                            c(
                                                                  arg,
                                                                "flap-trap-monitor" arg
                                                            )
                                                        ),
                                                        "avg-fdv-twoway-threshold" (
                                                            c(
                                                                  arg,
                                                                "flap-trap-monitor" arg
                                                            )
                                                        ),
                                                        "measurement-interval" (
                                                          ("2" | "5" | "15" | "30" | "60")
                                                        ),
                                                        "frame-delay" (
                                                            c(
                                                                "num-bins" arg,
                                                                "two-way" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                ),
                                                                "forward" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                ),
                                                                "backward" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                )
                                                            )
                                                        ),
                                                        "frame-delay-range" (
                                                            c(
                                                                "num-bins" arg,
                                                                "two-way" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                ),
                                                                "forward" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                ),
                                                                "backward" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                )
                                                            )
                                                        ),
                                                        "ifdv" (
                                                            c(
                                                                "num-bins" arg,
                                                                "two-way" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                ),
                                                                "forward" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                ),
                                                                "backward" (
                                                                    c(
                                                                        "lower-threshold-bin" arg
                                                                    )
                                                                )
                                                            )
                                                        ),
                                                        "availability" (
                                                            c(
                                                                "num-consecutive-pdus" arg,
                                                                "flr-threshold" arg,
                                                                "num-consecutive-intervals" arg,
                                                                "num-consecutive-highflr" arg
                                                            )
                                                        )
                                                    )
                                                ),
                                                "interface" arg (
                                                    c(
                                                        "enable-multiclass-loss-measurement",
                                                        "code-point-based-lm-accounting",
                                                        "priority-based-lm-accounting"
                                                    )
                                                ).as(:oneline),
                                                "enable-multiclass-loss-measurement",
                                                "code-point-based-lm-accounting",
                                                "priority-based-lm-accounting",
                                                "colorless-loss-measurement"
                                            )
                                        ),
                                        "connection-protection" (
                                            c(
                                                "mark-connection-protection-tlv",
                                                "uhp-label-lookup"
                                            )
                                        ),
                                        "no-aggregate-delegate-processing",
                                        "enhanced-cfm-mode",
                                        "traceoptions" (
                                          cfm_traceoptions
                                        ),
                                        "action-profile" arg (
                                            c(
                                                "event" (
                                                    c(
                                                        "interface-status-tlv" (
                                                          ("down" | "lower-layer-down")
                                                        ),
                                                        "port-status-tlv" (
                                                          ("blocked")
                                                        ),
                                                        "adjacency-loss",
                                                        "rdi",
                                                        "connection-protection-tlv" (
                                                          ("using-working-path" | "using-protection-path")
                                                        ),
                                                        "server-mep-defects" (
                                                          ("link-loss-defect" | "l2circuit-defect" | "l2vpn-defect")
                                                        ),
                                                        "ais-trigger-condition" (
                                                          ("all-defects" | "adjacency-loss" | "cross-connect-ccm" | "erroneous-ccm" | "receive-ais")
                                                        )
                                                    )
                                                ),
                                                "action" (
                                                    c(
                                                        "interface-down",
                                                        "revertive-interface-down",
                                                        "non-revertive-interface-down",
                                                        "propagate-remote-mac-flush",
                                                        "log-and-generate-ais" (
                                                            c(
                                                                "level" arg,
                                                                "interval" (
                                                                  ("1s" | "1m")
                                                                ),
                                                                "priority" arg
                                                            )
                                                        )
                                                    )
                                                ),
                                                "clear-action" (
                                                    c(
                                                        "interface-down" (
                                                            c(
                                                                "peer-interface"
                                                            )
                                                        ).as(:oneline),
                                                        "propagate-remote-mac-flush"
                                                    )
                                                ),
                                                "default-actions" (
                                                    c(
                                                        "interface-down"
                                                    )
                                                )
                                            )
                                        ),
                                        "server-mep" arg (
                                            c(
                                                "protocol" (
                                                    c(
                                                        c(
                                                          "l2circuit" (
                                                              c(
                                                                  "interface" (
                                                                      c(
                                                                            interface_name
                                                                      )
                                                                  ).as(:oneline)
                                                              )
                                                          ).as(:oneline),
                                                          "l2vpn" (
                                                              c(
                                                                  "interface" (
                                                                      c(
                                                                            interface_name
                                                                      )
                                                                  ).as(:oneline)
                                                              )
                                                          ).as(:oneline),
                                                          "ethernet" (
                                                              c(
                                                                  "interface" (
                                                                      c(
                                                                            interface_device
                                                                      )
                                                                  ).as(:oneline)
                                                              )
                                                          ).as(:oneline)
                                                        )
                                                    )
                                                ),
                                                "action-profile" (
                                                    c(
                                                        arg
                                                    )
                                                )
                                            )
                                        ),
                                        "policer" (
                                            c(
                                                "continuity-check" arg,
                                                "other" arg,
                                                "all" arg
                                            )
                                        ),
                                        "linktrace" (
                                            c(
                                                "path-database-size" arg,
                                                "age" (
                                                  ("10s" | "30s" | "1m" | "10m" | "30m")
                                                )
                                            )
                                        ),
                                        "maintenance-domain" ("default-0" | "default-1" | "default-2" | "default-3" | "default-4" | "default-5" | "default-6" | "default-7" | arg) (
                                            c(
                                                "bridge-domain" arg (
                                                    c(
                                                        "vlan-id" arg
                                                    )
                                                ).as(:oneline),
                                                "vlan" arg.as(:oneline),
                                                "virtual-switch" arg (
                                                    c(
                                                        "bridge-domain" arg (
                                                            c(
                                                                "vlan-id" arg
                                                            )
                                                        ).as(:oneline)
                                                    )
                                                ),
                                                "instance" arg.as(:oneline),
                                                "interface" arg.as(:oneline),
                                                "level" arg,
                                                "name-format" (
                                                  ("none" | "dns" | "mac+2oct" | "character-string")
                                                ),
                                                "mip-half-function" (
                                                  ("none" | "default" | "explicit")
                                                ),
                                                "maintenance-association" arg (
                                                    c(
                                                        "debug-session",
                                                        "short-name-format" (
                                                          ("2octet" | "rfc-2685-vpn-id" | "vlan" | "character-string" | "icc")
                                                        ),
                                                        "protect-maintenance-association" (
                                                            c(
                                                                  arg,
                                                                "aps-profile" arg,
                                                                "detect-path-type"
                                                            )
                                                        ).as(:oneline),
                                                        "primary-vid" (
                                                          ("none" | arg)
                                                        ),
                                                        "continuity-check" (
                                                            c(
                                                                "interval" (
                                                                  ("10ms" | "100ms" | "1s" | "10s" | "1m" | "10m" | "3.3ms")
                                                                ),
                                                                "loss-threshold" arg,
                                                                "hold-interval" arg,
                                                                "port-status-tlv",
                                                                "interface-status-tlv",
                                                                "connection-protection-tlv",
                                                                "convey-loss-threshold",
                                                                "sendid-tlv" (
                                                                    c(
                                                                        "send-chassis-tlv"
                                                                    )
                                                                )
                                                            )
                                                        ),
                                                        "mip-half-function" (
                                                          ("none" | "default" | "explicit" | "defer")
                                                        ),
                                                        "mep" arg (
                                                            c(
                                                                "interface" (
                                                                    c(
                                                                          interface_unit,
                                                                        "vlan" arg,
                                                                        c(
                                                                          "working",
                                                                          "protect"
                                                                        )
                                                                    )
                                                                ).as(:oneline),
                                                                "direction" (
                                                                  ("up" | "down")
                                                                ),
                                                                "priority" arg,
                                                                "auto-discovery",
                                                                "action-profile" arg,
                                                                "remote-mep" arg (
                                                                    c(
                                                                        "action-profile" arg,
                                                                        "sla-iterator-profile" arg (
                                                                            c(
                                                                                "iteration-count" arg,
                                                                                "priority" arg,
                                                                                "data-tlv-size" arg
                                                                            )
                                                                        ),
                                                                        "detect-loc"
                                                                    )
                                                                ),
                                                                "lowest-priority-defect" (
                                                                  ("all-defects" | "mac-rem-err-xcon" | "rem-err-xcon" | "err-xcon" | "xcon" | "no-defect")
                                                                )
                                                            )
                                                        ),
                                                        "policer" (
                                                            c(
                                                                "continuity-check" arg,
                                                                "other" arg,
                                                                "all" arg
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        ),
                                        "sendid-tlv" (
                                            c(
                                                "send-chassis-tlv"
                                            )
                                        )
                                    )
                                ),
                                "evcs" arg (
                                    c(
                                        "evc-protocol" (
                                            c(
                                                c(
                                                  "cfm" (
                                                      c(
                                                          "maintenance-domain" arg,
                                                          "maintenance-association" arg,
                                                          "mep" arg,
                                                          "faults" (
                                                              c(
                                                                  "rdi"
                                                              )
                                                          )
                                                      )
                                                  ).as(:oneline),
                                                  "vpls" (
                                                      c(
                                                          "routing-instance" arg
                                                      )
                                                  ).as(:oneline),
                                                  "l2circuit" (
                                                      c(
                                                          "interface" (
                                                              c(
                                                                    interface_name
                                                              )
                                                          ).as(:oneline)
                                                      )
                                                  ),
                                                  "l2vpn" (
                                                      c(
                                                          "interface" (
                                                              c(
                                                                    interface_name
                                                              )
                                                          ).as(:oneline)
                                                      )
                                                  )
                                                )
                                            )
                                        ).as(:oneline),
                                        "remote-uni-count" arg,
                                        "async-status-msg-transmit-interval" arg,
                                        "multipoint-to-multipoint"
                                    )
                                ),
                                "lmi" (
                                    c(
                                        "traceoptions" (
                                            c(
                                                "no-remote-trace",
                                                "file" (
                                                    c(
                                                          arg,
                                                        "size" arg,
                                                        "files" arg,
                                                        "world-readable",
                                                        "no-world-readable",
                                                        "match" (
                                                          regular_expression
                                                        )
                                                    )
                                                ).as(:oneline),
                                                "flag" (("configuration" | "routing-socket" | "protocol" | "init" | "error" | "packet" | "all")).as(:oneline)
                                            )
                                        ),
                                        "status-counter" arg,
                                        "polling-verification-timer" arg,
                                        "interface" arg (
                                            c(
                                                "uni-id" arg,
                                                "status-counter" arg,
                                                "polling-verification-timer" arg,
                                                "evc-map-type" (
                                                  ("all-to-one-bundling" | "service-multiplexing" | "bundling")
                                                ),
                                                "evc" arg (
                                                    c(
                                                        "default-evc",
                                                        "vlan-list" arg
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "fnp" (
                                    c(
                                        "traceoptions" (
                                            c(
                                                "file" (
                                                  trace_file_type
                                                ),
                                                "flag" (("events" | "pdu" | "timers" | "error" | "all")).as(:oneline)
                                            )
                                        ),
                                        "interval" (
                                          ("100ms" | "1s" | "10s" | "1m" | "10m")
                                        ),
                                        "loss-threshold" arg,
                                        "interface" arg (
                                            c(
                                                "domain-id" arg
                                            )
                                        )
                                    )
                                )
                            )
                        ),
                        "gre-tunnel" (
                            c(
                                "traceoptions" (
                                    c(
                                        "no-remote-trace",
                                        "file" (
                                            c(
                                                  arg,
                                                "size" arg,
                                                "files" arg,
                                                "world-readable",
                                                "no-world-readable",
                                                "match" (
                                                  regular_expression
                                                )
                                            )
                                        ).as(:oneline),
                                        "flag" (("configuration" | "routing-socket" | "protocol" | "all")).as(:oneline)
                                    )
                                ),
                                "interface" arg (
                                    c(
                                        "keepalive-time" arg,
                                        "hold-time" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "mld" (
                    c(
                        "traceoptions" (
                            c(
                                "file" (
                                  trace_file_type
                                ),
                                "flag" (("packets" | "query" | "report" | "leave" | "mtrace" | "group" | "client-notification" | "host-notification" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                                    c(
                                        "send",
                                        "receive",
                                        "detail",
                                        "disable"
                                    )
                                ).as(:oneline)
                            )
                        ),
                        "query-interval" arg,
                        "query-response-interval" arg,
                        "query-last-member-interval" arg,
                        "robust-count" arg,
                        "maximum-transmit-rate" arg,
                        "accounting",
                        "interface" ("$junos-interface-name" | arg) (
                            c(
                                  ("disable"),
                                "version" arg,
                                "static" (
                                    c(
                                        "group" arg (
                                            c(
                                                "group-increment" (
                                                  ipv6addr
                                                ),
                                                "group-count" arg,
                                                "exclude",
                                                "source" arg (
                                                    c(
                                                        "source-increment" (
                                                          ipv6addr
                                                        ),
                                                        "source-count" arg
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "ssm-map" arg,
                                "ssm-map-policy" (
                                  policy_algebra
                                ),
                                "immediate-leave",
                                "group-policy" (
                                  policy_algebra
                                ),
                                "group-limit" arg,
                                "group-threshold" arg,
                                "log-interval" arg,
                                "accounting",
                                "no-accounting",
                                "passive" (
                                    c(
                                        "allow-receive",
                                        "send-general-query",
                                        "send-group-query"
                                    )
                                ).as(:oneline),
                                "oif-map" (
                                  policy_algebra
                                ),
                                "distributed"
                            )
                        )
                    )
                ),
                "pim" (
                  juniper_protocols_pim
                ),
                "router-advertisement" (
                    c(
                        "traceoptions" (
                            c(
                                "file" (
                                  trace_file_type
                                ),
                                "flag" (("route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")).as(:oneline)
                            )
                        ),
                        "interface" ("$junos-interface-name" | arg) (
                            c(
                                "preference" (
                                  ("medium" | "high" | "low")
                                ),
                                "max-advertisement-interval" arg,
                                "min-advertisement-interval" arg,
                                "managed-configuration",
                                "no-managed-configuration",
                                "other-stateful-configuration",
                                "no-other-stateful-configuration",
                                "link-mtu",
                                "no-link-mtu",
                                "solicit-router-advertisement-unicast",
                                "reachable-time" arg,
                                "retransmit-timer" arg,
                                "virtual-router-only",
                                "current-hop-limit" arg,
                                "default-lifetime" arg,
                                "dns-server-address" ("$junos-ipv6-dns-server-address" | arg) (
                                    c(
                                        "lifetime" arg
                                    )
                                ),
                                "prefix" arg (
                                    c(
                                        "valid-lifetime" arg,
                                        "on-link",
                                        "no-on-link",
                                        "preferred-lifetime" arg,
                                        "autonomous",
                                        "no-autonomous"
                                    )
                                )
                            )
                        ),
                        "ra-secure" (
                            c(
                                "accept-current-hop-limit-min" arg,
                                "accept-current-hop-limit-max" arg,
                                "accept-reachable-time-min" arg,
                                "accept-reachable-time-max" arg,
                                "accept-retransmit-time-min" arg,
                                "accept-retransmit-time-max" arg
                            )
                        )
                    )
                )
            )
        ),
        "class-of-service" (
          juniper_class_of_service_options
        ),
        "routing-options" (
            c(
                "rib" arg (
                    c(
                        "static" (
                            c(
                                "rib-group" arg,
                                "defaults" (
                                    c(
                                        "retain",
                                        "no-retain",
                                        "install",
                                        "no-install",
                                        "readvertise",
                                        "no-readvertise",
                                        "resolve",
                                        "no-resolve",
                                        "longest-match",
                                        "no-longest-match",
                                        c(
                                          "active",
                                          "passive"
                                        ),
                                        "metric" (
                                          rib_static_metric_type
                                        ),
                                        "metric2" (
                                          rib_static_metric_type
                                        ),
                                        "metric3" (
                                          rib_static_metric_type
                                        ),
                                        "metric4" (
                                          rib_static_metric_type
                                        ),
                                        "tag" (
                                          rib_static_metric_type
                                        ),
                                        "tag2" (
                                          rib_static_metric_type
                                        ),
                                        "preference" (
                                          rib_static_metric_type
                                        ),
                                        "preference2" (
                                          rib_static_metric_type
                                        ),
                                        "color" (
                                          rib_static_metric_type
                                        ),
                                        "color2" (
                                          rib_static_metric_type
                                        ),
                                        "community" (
                                          community
                                        ),
                                        "as-path" (
                                            c(
                                                "path" arg,
                                                "origin" (
                                                  ("igp" | "egp" | "incomplete")
                                                ),
                                                "atomic-aggregate",
                                                "aggregator" (
                                                    c(
                                                        arg,
                                                          ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "route" arg (
                                    c(
                                        c(
                                          "next-hop" (
                                            ipaddr_or_interface
                                          ),
                                          "reject",
                                          "discard",
                                          "receive",
                                          "next-table" arg
                                        ),
                                        "qualified-next-hop" (
                                          qualified_nh_obj
                                        ),
                                        "lsp-next-hop" (
                                          lsp_nh_obj
                                        ),
                                        "static-lsp-next-hop" (
                                          lsp_nh_obj
                                        ),
                                        "p2mp-lsp-next-hop" (
                                          lsp_nh_obj
                                        ),
                                        "p2mp-ldp-next-hop" (
                                          p2mp_ldp_lsp_nh_obj
                                        ),
                                        "backup-pe-group" arg,
                                        "bfd-liveness-detection" (
                                            c(
                                                "version" (
                                                  ("0" | "1" | "automatic")
                                                ),
                                                "minimum-interval" arg,
                                                "minimum-transmit-interval" arg,
                                                "minimum-receive-interval" arg,
                                                "multiplier" arg,
                                                c(
                                                  "no-adaptation"
                                                ),
                                                "transmit-interval" (
                                                    c(
                                                        "minimum-interval" arg,
                                                        "threshold" arg
                                                    )
                                                ),
                                                "detection-time" (
                                                    c(
                                                        "threshold" arg
                                                    )
                                                ),
                                                "authentication" (
                                                    c(
                                                        "key-chain" arg,
                                                        "algorithm" (
                                                          ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                                        ),
                                                        "loose-check"
                                                    )
                                                ),
                                                "neighbor" (
                                                  ipaddr
                                                ),
                                                "local-address" (
                                                  ipaddr
                                                ),
                                                "holddown-interval" arg,
                                                "minimum-receive-ttl" arg
                                            )
                                        ),
                                        "retain",
                                        "no-retain",
                                        "install",
                                        "no-install",
                                        "readvertise",
                                        "no-readvertise",
                                        "resolve",
                                        "no-resolve",
                                        "longest-match",
                                        "no-longest-match",
                                        c(
                                          "active",
                                          "passive"
                                        ),
                                        "metric" (
                                          rib_static_metric_type
                                        ),
                                        "metric2" (
                                          rib_static_metric_type
                                        ),
                                        "metric3" (
                                          rib_static_metric_type
                                        ),
                                        "metric4" (
                                          rib_static_metric_type
                                        ),
                                        "tag" (
                                          rib_static_metric_type
                                        ),
                                        "tag2" (
                                          rib_static_metric_type
                                        ),
                                        "preference" (
                                          rib_static_metric_type
                                        ),
                                        "preference2" (
                                          rib_static_metric_type
                                        ),
                                        "color" (
                                          rib_static_metric_type
                                        ),
                                        "color2" (
                                          rib_static_metric_type
                                        ),
                                        "community" (
                                          community
                                        ),
                                        "as-path" (
                                            c(
                                                "path" arg,
                                                "origin" (
                                                  ("igp" | "egp" | "incomplete")
                                                ),
                                                "atomic-aggregate",
                                                "aggregator" (
                                                    c(
                                                        arg,
                                                          ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "static-route" (
                                    c(
                                        "bfd-admin-down" (
                                          ("active" | "passive")
                                        )
                                    )
                                ).as(:oneline),
                                "iso-route" arg (
                                    c(
                                        c(
                                          "next-hop" (
                                            ipaddr_or_interface
                                          ),
                                          "reject",
                                          "discard",
                                          "receive",
                                          "next-table" arg
                                        ),
                                        "qualified-next-hop" (
                                          qualified_nh_obj
                                        ),
                                        "lsp-next-hop" (
                                          lsp_nh_obj
                                        ),
                                        "static-lsp-next-hop" (
                                          lsp_nh_obj
                                        ),
                                        "p2mp-lsp-next-hop" (
                                          lsp_nh_obj
                                        ),
                                        "p2mp-ldp-next-hop" (
                                          p2mp_ldp_lsp_nh_obj
                                        ),
                                        "backup-pe-group" arg,
                                        "bfd-liveness-detection" (
                                            c(
                                                "version" (
                                                  ("0" | "1" | "automatic")
                                                ),
                                                "minimum-interval" arg,
                                                "minimum-transmit-interval" arg,
                                                "minimum-receive-interval" arg,
                                                "multiplier" arg,
                                                c(
                                                  "no-adaptation"
                                                ),
                                                "transmit-interval" (
                                                    c(
                                                        "minimum-interval" arg,
                                                        "threshold" arg
                                                    )
                                                ),
                                                "detection-time" (
                                                    c(
                                                        "threshold" arg
                                                    )
                                                ),
                                                "authentication" (
                                                    c(
                                                        "key-chain" arg,
                                                        "algorithm" (
                                                          ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                                        ),
                                                        "loose-check"
                                                    )
                                                ),
                                                "neighbor" (
                                                  ipaddr
                                                ),
                                                "local-address" (
                                                  ipaddr
                                                ),
                                                "holddown-interval" arg,
                                                "minimum-receive-ttl" arg
                                            )
                                        ),
                                        "retain",
                                        "no-retain",
                                        "install",
                                        "no-install",
                                        "readvertise",
                                        "no-readvertise",
                                        "resolve",
                                        "no-resolve",
                                        "longest-match",
                                        "no-longest-match",
                                        c(
                                          "active",
                                          "passive"
                                        ),
                                        "metric" (
                                          rib_static_metric_type
                                        ),
                                        "metric2" (
                                          rib_static_metric_type
                                        ),
                                        "metric3" (
                                          rib_static_metric_type
                                        ),
                                        "metric4" (
                                          rib_static_metric_type
                                        ),
                                        "tag" (
                                          rib_static_metric_type
                                        ),
                                        "tag2" (
                                          rib_static_metric_type
                                        ),
                                        "preference" (
                                          rib_static_metric_type
                                        ),
                                        "preference2" (
                                          rib_static_metric_type
                                        ),
                                        "color" (
                                          rib_static_metric_type
                                        ),
                                        "color2" (
                                          rib_static_metric_type
                                        ),
                                        "community" (
                                          community
                                        ),
                                        "as-path" (
                                            c(
                                                "path" arg,
                                                "origin" (
                                                  ("igp" | "egp" | "incomplete")
                                                ),
                                                "atomic-aggregate",
                                                "aggregator" (
                                                    c(
                                                        arg,
                                                          ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                "route-target-filter" arg (
                                    c(
                                        "neighbor" (
                                          ipaddr
                                        ),
                                        "group" arg,
                                        "local"
                                    )
                                )
                            )
                        ),
                        "martians" (
                          martian_type
                        ),
                        "aggregate" (
                          rib_aggregate_type
                        ),
                        "generate" (
                          rib_aggregate_type
                        ),
                        c(
                          "maximum-routes" (
                              c(
                                    arg,
                                  c(
                                    "threshold" arg,
                                    "log-only"
                                  ),
                                  "log-interval" arg
                              )
                          ).as(:oneline),
                          "maximum-paths" (
                              c(
                                    arg,
                                  c(
                                    "threshold" arg,
                                    "log-only"
                                  ),
                                  "log-interval" arg
                              )
                          ).as(:oneline)
                        ),
                        "maximum-prefixes" (
                            c(
                                  arg,
                                c(
                                  "threshold" arg,
                                  "log-only"
                                ),
                                "log-interval" arg
                            )
                        ).as(:oneline),
                        "multipath" (
                            c(
                                "vpn-unequal-cost" (
                                    c(
                                        "equal-external-internal"
                                    )
                                ).as(:oneline),
                                "as-path-compare"
                            )
                        ),
                        "protect" (
                            c(
                                "core"
                            )
                        ).as(:oneline),
                        "label" (
                            c(
                                "allocation" (
                                  policy_algebra
                                ),
                                "substitution" (
                                  policy_algebra
                                )
                            )
                        ),
                        "access" (
                            c(
                                "route" arg (
                                    c(
                                        "next-hop" (
                                          ipaddr_or_interface
                                        ),
                                        "qualified-next-hop" (
                                          qualified_nh_obj
                                        ),
                                        "metric" arg,
                                        "preference" arg,
                                        "tag" arg
                                    )
                                )
                            )
                        ),
                        "access-internal" (
                            c(
                                "route" arg (
                                    c(
                                        "next-hop" (
                                          ipaddr_or_interface
                                        ),
                                        "qualified-next-hop" (
                                          qualified_nh_obj
                                        )
                                    )
                                )
                            )
                        ),
                        "bgp-static" (
                            c(
                                "route" arg (
                                    c(
                                        "metric" (
                                          rib_static_metric_type
                                        ),
                                        "metric2" (
                                          rib_static_metric_type
                                        ),
                                        "metric3" (
                                          rib_static_metric_type
                                        ),
                                        "metric4" (
                                          rib_static_metric_type
                                        ),
                                        "tag" (
                                          rib_static_metric_type
                                        ),
                                        "tag2" (
                                          rib_static_metric_type
                                        ),
                                        "preference" (
                                          rib_static_metric_type
                                        ),
                                        "preference2" (
                                          rib_static_metric_type
                                        ),
                                        "color" (
                                          rib_static_metric_type
                                        ),
                                        "color2" (
                                          rib_static_metric_type
                                        ),
                                        "community" (
                                          community
                                        ),
                                        "as-path" (
                                            c(
                                                "path" arg,
                                                "origin" (
                                                  ("igp" | "egp" | "incomplete")
                                                ),
                                                "atomic-aggregate",
                                                "aggregator" (
                                                    c(
                                                        arg,
                                                          ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        ),
                        "flow" (
                            c(
                                "validation" (
                                  flow_validation
                                ),
                                "route" (
                                  flow_route_inet6
                                ),
                                "interface-group" (
                                  flow_interface_group
                                )
                            )
                        )
                    )
                ),
                "access" (
                    c(
                        "route" arg (
                            c(
                                "next-hop" (
                                  ipaddr_or_interface
                                ),
                                "qualified-next-hop" (
                                  qualified_nh_obj
                                ),
                                "metric" arg,
                                "preference" arg,
                                "tag" arg
                            )
                        )
                    )
                ),
                "access-internal" (
                    c(
                        "route" arg (
                            c(
                                "next-hop" (
                                  ipaddr_or_interface
                                ),
                                "qualified-next-hop" (
                                  qualified_nh_obj
                                )
                            )
                        )
                    )
                ),
                "multicast" (
                    c(
                        "traceoptions" (
                            c(
                                "file" (
                                  trace_file_type
                                ),
                                "flag" (("parse" | "config-internal" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                                    c(
                                        "disable"
                                    )
                                ).as(:oneline)
                            )
                        ),
                        "rpf" arg,
                        "scope" arg (
                            c(
                                "prefix" (
                                  ipprefix
                                ),
                                "interface" (
                                  interface_name
                                )
                            )
                        ),
                        "scope-policy" (
                          policy_algebra
                        ),
                        "flow-map" arg (
                            c(
                                "policy" (
                                  policy_algebra
                                ),
                                "bandwidth" (
                                    c(
                                        arg,
                                        "adaptive"
                                    )
                                ).as(:oneline),
                                "redundant-sources" (
                                  ipaddr
                                ),
                                "forwarding-cache" (
                                    c(
                                        "timeout" (
                                            c(
                                                c(
                                                    arg,
                                                  "never" (
                                                      c(
                                                          "non-discard-entry-only"
                                                      )
                                                  )
                                                )
                                            )
                                        ).as(:oneline)
                                    )
                                )
                            )
                        ),
                        "resolve-filter" (
                          policy_algebra
                        ),
                        "ssm-groups" (
                          ipprefix
                        ),
                        "asm-override-ssm",
                        "rpf-check-policy" (
                          policy_algebra
                        ),
                        "pim-to-igmp-proxy" (
                            c(
                                "upstream-interface" (
                                  interface_name
                                )
                            )
                        ),
                        "pim-to-mld-proxy" (
                            c(
                                "upstream-interface" (
                                  interface_name
                                )
                            )
                        ),
                        "forwarding-cache" (
                            c(
                                "allow-maximum",
                                "family" (("inet" | "inet6")) (
                                    c(
                                        "threshold" (
                                            c(
                                                "suppress" arg,
                                                "reuse" arg,
                                                "mvpn-rpt-suppress" arg,
                                                "mvpn-rpt-reuse" arg,
                                                "log-warning" arg
                                            )
                                        )
                                    )
                                ),
                                "threshold" (
                                    c(
                                        "suppress" arg,
                                        "reuse" arg,
                                        "mvpn-rpt-suppress" arg,
                                        "mvpn-rpt-reuse" arg,
                                        "log-warning" arg
                                    )
                                ),
                                "timeout" arg
                            )
                        ),
                        "interface" (
                          multicast_interface_options_type
                        ),
                        "ssm-map" arg (
                            c(
                                "policy" (
                                  policy_algebra
                                ),
                                "source" (
                                  ipaddr
                                )
                            )
                        ),
                        "stream-protection" (
                            c(
                                "mofrr-primary-path-selection-by-routing",
                                "mofrr-disjoint-upstream-only",
                                "mofrr-no-backup-join",
                                "mofrr-asm-starg",
                                "policy" (
                                  policy_algebra
                                )
                            )
                        ),
                        "backup-pe-group" arg (
                            c(
                                "backups" (
                                  ipaddr
                                ),
                                "local-address" (
                                  ipaddr
                                )
                            )
                        ),
                        "omit-wildcard-address",
                        "local-address" (
                          ipv4addr
                        )
                    )
                )
            )
        ),
        "firewall" (
            c(
                "family" (
                    c(
                        "inet" (
                            c(
                                "dialer-filter" (
                                  inet_dialer_filter
                                ),
                                "prefix-action" (
                                  prefix_action
                                ),
                                "filter" (
                                  inet_filter
                                ),
                                "template" (
                                  inet_template
                                ),
                                "simple-filter" (
                                  inet_simple_filter
                                ),
                                "service-filter" (
                                  inet_service_filter
                                ),
                                "fast-update-filter" (
                                  inet_fuf
                                )
                            )
                        ),
                        "inet6" (
                            c(
                                "dialer-filter" (
                                  inet6_dialer_filter
                                ),
                                "filter" (
                                  inet6_filter
                                ),
                                "service-filter" (
                                  inet6_service_filter
                                ),
                                "fast-update-filter" (
                                  inet6_fuf
                                ),
                                "template" (
                                  inet6_template
                                )
                            )
                        ),
                        "mpls" (
                            c(
                                "dialer-filter" (
                                  mpls_dialer_filter
                                ),
                                "filter" (
                                  mpls_filter
                                ),
                                "template" (
                                  mpls_template
                                )
                            )
                        ),
                        "vpls" (
                            c(
                                "filter" (
                                  vpls_filter
                                )
                            )
                        ),
                        "evpn" (
                            c(
                                "filter" (
                                  vpls_filter
                                )
                            )
                        ),
                        "bridge" (
                            c(
                                "filter" (
                                  bridge_filter
                                )
                            )
                        ),
                        "ccc" (
                            c(
                                "filter" (
                                  ccc_filter
                                )
                            )
                        ),
                        "any" (
                            c(
                                "filter" (
                                  any_filter
                                ),
                                "template" (
                                  any_template
                                )
                            )
                        ),
                        "ethernet-switching" (
                            c(
                                "filter" (
                                  es_filter
                                ),
                                "template" (
                                  es_template
                                )
                            )
                        )
                    )
                ),
                "policer" (
                  firewall_policer
                ),
                "flexible-match" (
                  firewall_flexible_match
                ),
                "tunnel-end-point" (
                  tunnel_end_point
                ),
                "hierarchical-policer" (
                  firewall_hierpolicer
                ),
                "interface-set" (
                  interface_set_type
                ),
                "load-balance-group" (
                  firewall_load_balance_group
                ),
                "atm-policer" (
                  atm_policer_type
                ),
                "three-color-policer" (
                  three_color_policer_type
                ),
                "filter" (
                  inet_filter
                )
            )
        ),
        "services" (
            c(
                "aacl" (
                    c(
                        "rule" (
                          aacl_rule_object
                        ),
                        "rule-set" arg (
                            c(
                                "rule" arg
                            )
                        ),
                        "aacl-dyn-rule-set" arg (
                            c(
                                "rule" arg
                            )
                        )
                    )
                ),
                "captive-portal-content-delivery" (
                    c(
                        "rule" (
                          cpcd_rule_object_type
                        ),
                        "rule-set" arg (
                            c(
                                "rule" arg
                            )
                        ),
                        "profile" arg (
                            c(
                                c(
                                  "dynamic",
                                  "cpcd-rules" arg,
                                  "cpcd-rule-sets" arg
                                ),
                                "ipda-rewrite-options" (
                                    c(
                                        "destination-address" (
                                          ipaddr
                                        ),
                                        "destination-port" arg
                                    )
                                ),
                                "http-redirect-options" (
                                    c(
                                        arg
                                    )
                                )
                            )
                        ),
                        "traceoptions" (
                          cpcd_trace_options_type
                        )
                    )
                )
            )
        ),
        "profile-variable-set" (
          juniper_dynamic_profile_varset_object
        ),
        "policy-options" (
            c(
                "prefix-list" arg (
                    c(
                          prefix_list_items,
                        "apply-path" arg
                    )
                )
            )
        ),
        "extensible-subscriber-services" (
            c(
                "vsas" arg
            )
        ),
        "access-cac" (
            c(
                "interface" (
                  access_cac_interface_options
                )
            )
        )
    )
  )
end

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

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

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

rule(:flow_interface_group) do
    c(
          arg,
        "exclude"
    ).as(:oneline)
end

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

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

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

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

rule(:flow_validation) do
    c(
        "traceoptions" (
          flow_dep_traceoptions
        )
    )
end

rule(:flow_dep_traceoptions) do
    c(
        "file" (
          trace_file_type
        ),
        "flag" (("resolution" | "flash" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
            c(
                "send",
                "receive",
                "detail",
                "disable",
                "filter" (
                    c(
                        "match-on" (
                          ("prefix" | "route-attribute")
                        ),
                        "policy" (
                          policy_algebra
                        )
                    )
                ).as(:oneline)
            )
        ).as(:oneline)
    )
end

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

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

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

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

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

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

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

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

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

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

rule(:juniper_forwarding_sandbox_port_options) do
  arg.as(:arg) (
    c(
        "interface" arg
    )
  )
end

rule(:juniper_gnf) do
  arg.as(:arg) (
    c(
        "description" arg,
        "control-plane-bandwidth-percent" arg,
        "fpcs" arg
    )
  )
end

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

rule(:arp_interface_type) do
  arg.as(:arg) (
    c(
        "aging-timer" arg
    )
  )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:jsscd_static_subscribers_type) do
    c(
        "access-profile" (
          jsscd_access_profile_type
        ),
        "dynamic-profile" (
          jsscd_dynamic_profile_type
        ),
        "authentication" (
          jsscd_authentication_type
        ),
        "group" (
          jsscd_group_type
        ),
        "auto-login",
        "baseline-stats"
    )
end

rule(:jsscd_access_profile_type) do
    c(
        arg
    )
end

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

rule(:jsscd_dynamic_profile_type) do
    c(
          arg,
        "aggregate-clients" (
            c(
                c(
                  "merge",
                  "replace"
                )
            )
        )
    )
end

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

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

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

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

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

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

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

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

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

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

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

rule(:application_map_object) do
  arg.as(:arg) (
    c(
        "application" arg (
            c(
                "code-points" arg
            )
        ).as(:oneline)
    )
  )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:bandwidth_type) do
    c(
        arg,
        "ct0" arg,
        "ct1" arg,
        "ct2" arg,
        "ct3" arg
    )
end

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

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

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

rule(:juniper_default_ri_protocols_igmp_snooping) do
    c(
        "vlan" ("all" | arg) (
            c(
                "traceoptions" (
                    c(
                        "file" (
                          trace_file_type
                        ),
                        "flag" (("packets" | "query" | "report" | "leave" | "group" | "client-notification" | "route" | "normal" | "general" | "state" | "task" | "timer" | "all")) (
                            c(
                                "send",
                                "receive",
                                "detail",
                                "disable"
                            )
                        ).as(:oneline)
                    )
                ),
                "query-interval" arg,
                "l2-querier" (
                    c(
                        "source-address" (
                          ipv4addr
                        )
                    )
                ),
                "query-response-interval" arg,
                "query-last-member-interval" arg,
                "robust-count" arg,
                "immediate-leave",
                "proxy" (
                    c(
                        "source-address" (
                          ipv4addr
                        )
                    )
                ),
                "interface" arg (
                    c(
                        "multicast-router-interface",
                        "immediate-leave",
                        "host-only-interface",
                        "group-limit" arg,
                        "static" (
                            c(
                                "group" arg (
                                    c(
                                        "source" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "qualified-vlan" arg (
                    c(
                        "query-interval" arg,
                        "l2-querier" (
                            c(
                                "source-address" (
                                  ipv4addr
                                )
                            )
                        ),
                        "query-response-interval" arg,
                        "query-last-member-interval" arg,
                        "robust-count" arg,
                        "immediate-leave",
                        "proxy" (
                            c(
                                "source-address" (
                                  ipv4addr
                                )
                            )
                        ),
                        "interface" arg (
                            c(
                                "multicast-router-interface",
                                "immediate-leave",
                                "host-only-interface",
                                "group-limit" arg,
                                "static" (
                                    c(
                                        "group" arg (
                                            c(
                                                "source" arg
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                ),
                "disable"
            )
        ),
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("packets" | "query" | "report" | "leave" | "group" | "client-notification" | "host-notification" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                    c(
                        "send",
                        "receive",
                        "detail",
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "query-interval" arg,
        "query-response-interval" arg,
        "query-last-member-interval" arg,
        "robust-count" arg,
        "immediate-leave",
        "proxy" (
            c(
                "source-address" (
                  ipv4addr
                ),
                "irb"
            )
        ),
        "interface" arg (
            c(
                "multicast-router-interface",
                "immediate-leave",
                "host-only-interface",
                "group-limit" arg,
                "static" (
                    c(
                        "group" arg (
                            c(
                                "source" arg
                            )
                        )
                    )
                )
            )
        )
    )
end

rule(:juniper_default_ri_protocols_mld_snooping) do
    c(
        "vlan" ("all" | arg) (
            c(
                "traceoptions" (
                    c(
                        "file" (
                          trace_file_type
                        ),
                        "flag" (("packets" | "query" | "report" | "leave" | "group" | "client-notification" | "host-notification" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                            c(
                                "send",
                                "receive",
                                "detail",
                                "disable"
                            )
                        ).as(:oneline)
                    )
                ),
                "query-interval" arg,
                "query-response-interval" arg,
                "query-last-member-interval" arg,
                "robust-count" arg,
                "immediate-leave",
                "interface" arg (
                    c(
                        "multicast-router-interface",
                        "immediate-leave",
                        "host-only-interface",
                        "group-limit" arg,
                        "static" (
                            c(
                                "group" arg (
                                    c(
                                        "source" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "qualified-vlan" arg (
                    c(
                        "query-interval" arg,
                        "query-response-interval" arg,
                        "query-last-member-interval" arg,
                        "robust-count" arg,
                        "immediate-leave",
                        "interface" arg (
                            c(
                                "multicast-router-interface",
                                "immediate-leave",
                                "host-only-interface",
                                "group-limit" arg,
                                "static" (
                                    c(
                                        "group" arg (
                                            c(
                                                "source" arg
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ),
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("packets" | "query" | "report" | "leave" | "group" | "client-notification" | "host-notification" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                    c(
                        "send",
                        "receive",
                        "detail",
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "query-interval" arg,
        "query-response-interval" arg,
        "query-last-member-interval" arg,
        "robust-count" arg,
        "immediate-leave",
        "proxy" (
            c(
                "source-address" (
                  ipv6addr
                ),
                "irb"
            )
        ),
        "interface" arg (
            c(
                "multicast-router-interface",
                "immediate-leave",
                "host-only-interface",
                "group-limit" arg,
                "static" (
                    c(
                        "group" arg (
                            c(
                                "source" arg
                            )
                        )
                    )
                )
            )
        )
    )
end

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

rule(:juniper_protocols_amt) do
    c(
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("packets" | "errors" | "tunnels" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                    c(
                        "send",
                        "receive",
                        "detail",
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "relay" (
          juniper_protocols_amt_relay
        )
    )
end

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

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

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

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

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

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

rule(:bgp_afi_default) do
    c(
        "prefix-limit" (
          bgpaf_prefix_limit
        ),
        "accepted-prefix-limit" (
          bgpaf_accepted_prefix_limit
        ),
        "rib-group" (
          rib_group_inet_type
        ),
        "add-path" (
          apath_options
        ),
        "aigp" (
          bgpaf_aigp_options
        ),
        "damping",
        "local-ipv4-address" (
          ipv4addr
        ),
        "loops" (
          bgpaf_loops
        ).as(:oneline),
        "delay-route-advertisements" (
            c(
                "minimum-delay" (
                    c(
                        "routing-uptime" arg,
                        "inbound-convergence" arg
                    )
                ),
                "maximum-delay" (
                    c(
                        "route-age" arg,
                        "routing-uptime" arg
                    )
                )
            )
        ),
        "graceful-restart" (
          bgp_af_gr
        ),
        "extended-nexthop",
        "no-install",
        "output-queue-priority" (
          bgp_output_queue_priority_class
        ),
        "route-refresh-priority" (
          bgp_output_queue_priority_class
        ),
        "withdraw-priority" (
          bgp_output_queue_priority_class
        )
    )
end

rule(:apath_options) do
    c(
        "receive",
        "send" (
            c(
                "prefix-policy" (
                  policy_algebra
                ),
                "path-count" arg,
                "multipath"
            )
        )
    )
end

rule(:bgp_afi_flow) do
    c(
        "prefix-limit" (
          bgpaf_prefix_limit
        ),
        "accepted-prefix-limit" (
          bgpaf_accepted_prefix_limit
        ),
        "rib-group" (
          rib_group_inet_type
        ),
        "add-path" (
          apath_options
        ),
        "aigp" (
          bgpaf_aigp_options
        ),
        "damping",
        "local-ipv4-address" (
          ipv4addr
        ),
        "loops" (
          bgpaf_loops
        ).as(:oneline),
        "delay-route-advertisements" (
            c(
                "minimum-delay" (
                    c(
                        "routing-uptime" arg,
                        "inbound-convergence" arg
                    )
                ),
                "maximum-delay" (
                    c(
                        "route-age" arg,
                        "routing-uptime" arg
                    )
                )
            )
        ),
        "graceful-restart" (
          bgp_af_gr
        ),
        "extended-nexthop",
        "no-install",
        "output-queue-priority" (
          bgp_output_queue_priority_class
        ),
        "route-refresh-priority" (
          bgp_output_queue_priority_class
        ),
        "withdraw-priority" (
          bgp_output_queue_priority_class
        ),
        "no-validate" (
          policy_algebra
        ),
        "strip-nexthop",
        "allow-policy-add-nexthop"
    )
end

rule(:bgp_afi_inet6_labeled) do
    c(
        "prefix-limit" (
          bgpaf_prefix_limit
        ),
        "accepted-prefix-limit" (
          bgpaf_accepted_prefix_limit
        ),
        "rib-group" (
          rib_group_inet_type
        ),
        "add-path" (
          apath_options
        ),
        "aigp" (
          bgpaf_aigp_options
        ),
        "damping",
        "local-ipv4-address" (
          ipv4addr
        ),
        "loops" (
          bgpaf_loops
        ).as(:oneline),
        "delay-route-advertisements" (
            c(
                "minimum-delay" (
                    c(
                        "routing-uptime" arg,
                        "inbound-convergence" arg
                    )
                ),
                "maximum-delay" (
                    c(
                        "route-age" arg,
                        "routing-uptime" arg
                    )
                )
            )
        ),
        "graceful-restart" (
          bgp_af_gr
        ),
        "extended-nexthop",
        "no-install",
        "output-queue-priority" (
          bgp_output_queue_priority_class
        ),
        "route-refresh-priority" (
          bgp_output_queue_priority_class
        ),
        "withdraw-priority" (
          bgp_output_queue_priority_class
        ),
        "aggregate-label" (
            c(
                "community" arg
            )
        ),
        "per-group-label",
        "traffic-statistics" (
          bgpaf_traffic_statistics
        ),
        "rib" (
            c(
                "inet6.3"
            )
        ),
        "explicit-null" (
            c(
                "connected-only"
            )
        ).as(:oneline),
        "protection".as(:oneline)
    )
end

rule(:bgp_afi_l2vpn) do
    c(
        "prefix-limit" (
          bgpaf_prefix_limit
        ),
        "accepted-prefix-limit" (
          bgpaf_accepted_prefix_limit
        ),
        "rib-group" (
          rib_group_inet_type
        ),
        "add-path" (
          apath_options
        ),
        "aigp" (
          bgpaf_aigp_options
        ),
        "damping",
        "local-ipv4-address" (
          ipv4addr
        ),
        "loops" (
          bgpaf_loops
        ).as(:oneline),
        "delay-route-advertisements" (
            c(
                "minimum-delay" (
                    c(
                        "routing-uptime" arg,
                        "inbound-convergence" arg
                    )
                ),
                "maximum-delay" (
                    c(
                        "route-age" arg,
                        "routing-uptime" arg
                    )
                )
            )
        ),
        "graceful-restart" (
          bgp_af_gr
        ),
        "extended-nexthop",
        "no-install",
        "output-queue-priority" (
          bgp_output_queue_priority_class
        ),
        "route-refresh-priority" (
          bgp_output_queue_priority_class
        ),
        "withdraw-priority" (
          bgp_output_queue_priority_class
        ),
        "egress-protection" (
            c(
                "context-identifier" (
                    c(
                          ipv4addr
                    )
                ),
                "keep-import" (
                  policy_algebra
                )
            )
        )
    )
end

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

rule(:bgp_afi_topo) do
    c(
        "prefix-limit" (
          bgpaf_prefix_limit
        ),
        "accepted-prefix-limit" (
          bgpaf_accepted_prefix_limit
        ),
        "rib-group" (
          rib_group_inet_type
        ),
        "add-path" (
          apath_options
        ),
        "aigp" (
          bgpaf_aigp_options
        ),
        "damping",
        "local-ipv4-address" (
          ipv4addr
        ),
        "loops" (
          bgpaf_loops
        ).as(:oneline),
        "delay-route-advertisements" (
            c(
                "minimum-delay" (
                    c(
                        "routing-uptime" arg,
                        "inbound-convergence" arg
                    )
                ),
                "maximum-delay" (
                    c(
                        "route-age" arg,
                        "routing-uptime" arg
                    )
                )
            )
        ),
        "graceful-restart" (
          bgp_af_gr
        ),
        "extended-nexthop",
        "no-install",
        "output-queue-priority" (
          bgp_output_queue_priority_class
        ),
        "route-refresh-priority" (
          bgp_output_queue_priority_class
        ),
        "withdraw-priority" (
          bgp_output_queue_priority_class
        ),
        "protection".as(:oneline),
        "topology" arg (
            c(
                "community" arg
            )
        )
    )
end

rule(:bgp_afi_vpn) do
    c(
        "prefix-limit" (
          bgpaf_prefix_limit
        ),
        "accepted-prefix-limit" (
          bgpaf_accepted_prefix_limit
        ),
        "rib-group" (
          rib_group_inet_type
        ),
        "add-path" (
          apath_options
        ),
        "aigp" (
          bgpaf_aigp_options
        ),
        "damping",
        "local-ipv4-address" (
          ipv4addr
        ),
        "loops" (
          bgpaf_loops
        ).as(:oneline),
        "delay-route-advertisements" (
            c(
                "minimum-delay" (
                    c(
                        "routing-uptime" arg,
                        "inbound-convergence" arg
                    )
                ),
                "maximum-delay" (
                    c(
                        "route-age" arg,
                        "routing-uptime" arg
                    )
                )
            )
        ),
        "graceful-restart" (
          bgp_af_gr
        ),
        "extended-nexthop",
        "no-install",
        "output-queue-priority" (
          bgp_output_queue_priority_class
        ),
        "route-refresh-priority" (
          bgp_output_queue_priority_class
        ),
        "withdraw-priority" (
          bgp_output_queue_priority_class
        ),
        "aggregate-label" (
            c(
                "community" arg
            )
        )
    )
end

rule(:bgp_afi_vpn_protection) do
    c(
        "prefix-limit" (
          bgpaf_prefix_limit
        ),
        "accepted-prefix-limit" (
          bgpaf_accepted_prefix_limit
        ),
        "rib-group" (
          rib_group_inet_type
        ),
        "add-path" (
          apath_options
        ),
        "aigp" (
          bgpaf_aigp_options
        ),
        "damping",
        "local-ipv4-address" (
          ipv4addr
        ),
        "loops" (
          bgpaf_loops
        ).as(:oneline),
        "delay-route-advertisements" (
            c(
                "minimum-delay" (
                    c(
                        "routing-uptime" arg,
                        "inbound-convergence" arg
                    )
                ),
                "maximum-delay" (
                    c(
                        "route-age" arg,
                        "routing-uptime" arg
                    )
                )
            )
        ),
        "graceful-restart" (
          bgp_af_gr
        ),
        "extended-nexthop",
        "no-install",
        "output-queue-priority" (
          bgp_output_queue_priority_class
        ),
        "route-refresh-priority" (
          bgp_output_queue_priority_class
        ),
        "withdraw-priority" (
          bgp_output_queue_priority_class
        ),
        "aggregate-label" (
            c(
                "community" arg
            )
        ),
        "egress-protection" (
            c(
                "context-identifier" (
                    c(
                          ipv4addr
                    )
                ),
                "keep-import" (
                  policy_algebra
                )
            )
        )
    )
end

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

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

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

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

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

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

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

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

rule(:juniper_protocols_dot1x) do
    c(
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("dot1x-debug" | "parse" | "esw-if" | "eapol" | "config-internal" | "normal" | "general" | "state" | "task" | "timer" | "vlan" | "all" | "dot1x-ipc" | "dot1x-event" | "iccp")) (
                    c(
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "authenticator" (
            c(
                "authentication-profile-name" arg,
                "no-mac-table-binding",
                "radius-options" (
                  ("use-vlan-name" | "use-vlan-id")
                ),
                "static" arg (
                    c(
                        "vlan-assignment" arg,
                        "bridge-domain-assignment" arg,
                        "interface" (
                          interface_name
                        )
                    )
                ),
                "interface" ("all" | arg) (
                    c(
                        "authentication-order" (
                          ("dot1x" | "mac-radius" | "captive-portal")
                        ),
                        "disable",
                        "supplicant" (
                          ("single" | "single-secure" | "multiple")
                        ),
                        "retries" arg,
                        "quiet-period" arg,
                        "transmit-period" arg,
                        "mac-radius" (
                            c(
                                "restrict",
                                "flap-on-disconnect",
                                "authentication-protocol" (
                                    c(
                                        c(
                                          "eap-md5",
                                          "pap",
                                          "eap-peap" (
                                              c(
                                                  "resume"
                                              )
                                          )
                                        )
                                    )
                                )
                            )
                        ),
                        c(
                          "no-reauthentication",
                          "reauthentication" arg
                        ),
                        "supplicant-timeout" arg,
                        "server-timeout" arg,
                        "maximum-requests" arg,
                        "guest-vlan" arg,
                        "guest-bridge-domain" arg,
                        "server-reject-vlan" (
                            c(
                                arg,
                                "block-interval" arg,
                                "eapol-block"
                            )
                        ).as(:oneline),
                        "server-reject-bridge-domain" (
                            c(
                                arg,
                                "block-interval" arg,
                                "eapol-block"
                            )
                        ).as(:oneline),
                        "eapol-block" (
                            c(
                                "server-fail" (
                                    c(
                                          arg
                                    )
                                ),
                                "mac-radius",
                                "captive-portal"
                            )
                        ),
                        "lldp-med-bypass",
                        "server-fail" (
                            c(
                                c(
                                  "deny",
                                  "permit",
                                  "vlan-name" arg,
                                  "bridge-domain" arg,
                                  "use-cache"
                                )
                            )
                        ).as(:oneline),
                        "server-fail-voip" (
                            c(
                                c(
                                  "deny",
                                  "permit",
                                  "vlan-name" arg,
                                  "use-cache"
                                )
                            )
                        ).as(:oneline),
                        "redirect-url" arg,
                        "no-tagged-mac-authentication"
                    )
                )
            )
        )
    )
end

rule(:juniper_protocols_esis) do
    c(
          ("disable"),
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("error" | "esh" | "ish" | "graceful-restart" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                    c(
                        "send",
                        "receive",
                        "detail",
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "preference" arg,
        "graceful-restart" (
            c(
                  ("disable"),
                "restart-duration" arg
            )
        ).as(:oneline),
        "interface" arg (
            c(
                "hold-time" arg,
                "end-system-configuration-timer" arg,
                  ("disable")
            )
        )
    )
end

rule(:juniper_protocols_isis) do
    c(
          ("disable"),
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("error" | "spf" | "packets" | "hello" | "lsp" | "psn" | "csn" | "layer2-map" | "lsp-generation" | "graceful-restart" | "ldp-synchronization" | "nsr-synchronization" | "traffic-statistics" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                    c(
                        "send",
                        "receive",
                        "detail",
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "export" (
          policy_algebra
        ),
        "import" (
          policy_algebra
        ),
        "reference-bandwidth" arg,
        "layer2-map",
        "no-layer2-map",
        "lsp-lifetime" arg,
        "max-lsp-size" arg,
        "max-hello-size" arg,
        "max-snp-size" arg,
        "spf-delay" arg,
        "authentication-key" (
          unreadable
        ),
        "authentication-type" (
          ("md5" | "simple")
        ),
        "loose-authentication-check",
        "max-areas" arg,
        "no-authentication-check",
        "no-ipv4-routing",
        "no-ipv6-routing",
        "clns-routing",
        "clns-updown-compatibility",
        "no-adjacency-holddown",
        "multicast-topology",
        "ignore-attached-bit",
        "rib-group" (
          rib_group_type
        ),
        "spf-options" (
            c(
                "delay" arg,
                "holddown" arg,
                "rapid-runs" arg,
                "multipath" (
                    c(
                        "weighted" (
                            c(
                                "one-hop"
                            )
                        )
                    )
                )
            )
        ),
        "backup-spf-options" (
            c(
                "per-prefix-calculation",
                "remote-backup-calculation",
                "node-link-degradation",
                "use-source-packet-routing"
            )
        ),
        "topologies" (
            c(
                "ipv4-multicast",
                "ipv6-unicast",
                "ipv6-multicast"
            )
        ),
        "overload" (
            c(
                "timeout" arg,
                "advertise-high-metrics",
                "allow-route-leaking"
            )
        ),
        "traffic-engineering" (
            c(
                  ("disable"),
                "credibility-protocol-preference",
                "ipv4-multicast-rpf-routes",
                "ignore-lsp-metrics",
                "family" (("inet" | "inet6" | "inet-mpls" | "inet6-mpls")) (
                    c(
                        "shortcuts" (
                            c(
                                "multicast-rpf-routes"
                            )
                        )
                    )
                ),
                "shortcuts" (
                    c(
                        "ignore-lsp-metrics"
                    )
                ),
                "multipath" (
                    c(
                        "lsp-equal-cost"
                    )
                )
            )
        ),
        "graceful-restart" (
            c(
                  ("disable"),
                "helper-disable",
                "restart-duration" arg
            )
        ).as(:oneline),
        "source-packet-routing" (
            c(
                "adjacency-segment" (
                    c(
                        "hold-time" arg
                    )
                ),
                "srgb" (
                    c(
                        "start-label" arg,
                        "index-range" arg
                    )
                ).as(:oneline),
                "node-segment" (
                    c(
                        "ipv4-index" arg,
                        "ipv6-index" arg,
                        "index-range" arg
                    )
                ),
                "explicit-null"
            )
        ),
        "level" arg (
            c(
                  ("disable"),
                "authentication-key" (
                  unreadable
                ),
                "authentication-type" (
                  ("md5" | "simple")
                ),
                "purge-originator" (
                  ("self" | "empty")
                ),
                "no-hello-authentication",
                "no-csnp-authentication",
                "no-psnp-authentication",
                "authentication-key-chain" arg,
                "wide-metrics-only",
                "preference" arg,
                "external-preference" arg,
                "labeled-preference" arg,
                "prefix-export-limit" arg,
                "source-packet-routing" (
                    c(
                          ("disable")
                    )
                )
            )
        ),
        "interface" arg (
            c(
                  ("disable"),
                "authentication-key" (
                  unreadable
                ),
                "authentication-type" (
                  ("md5" | "simple")
                ),
                "flood-group" arg,
                "no-advertise-adjacency-segment",
                "hello-authentication-key" (
                  unreadable
                ),
                "hello-authentication-type" (
                  ("md5" | "simple")
                ),
                "hello-padding-type" (
                  ("strict" | "adaptive" | "loose" | "disable")
                ),
                "interface-group-holddown-delay" arg,
                "layer2-map",
                "no-layer2-map",
                "ldp-synchronization" (
                  ldp_sync_obj
                ),
                "max-hello-size" arg,
                "lsp-interval" arg,
                "csnp-interval" (
                    c(
                        c(
                            arg,
                          "disable"
                        )
                    )
                ).as(:oneline),
                "mesh-group" (
                    c(
                        c(
                          arg,
                          "blocked"
                        )
                    )
                ).as(:oneline),
                "point-to-point",
                c(
                  "link-protection",
                  "node-link-protection"
                ),
                "no-eligible-backup",
                "passive" (
                    c(
                        "remote-node-iso" (
                          sysid
                        ),
                        "remote-node-id" (
                          ipv4addr
                        )
                    )
                ),
                "no-eligible-remote-backup",
                "checksum",
                "no-unicast-topology",
                "no-ipv4-multicast",
                "no-ipv6-unicast",
                "no-ipv6-multicast",
                "no-adjacency-down-notification",
                "bfd-liveness-detection" (
                    c(
                        "version" (
                          ("0" | "1" | "automatic")
                        ),
                        "minimum-interval" arg,
                        "minimum-transmit-interval" arg,
                        "minimum-receive-interval" arg,
                        "multiplier" arg,
                        c(
                          "no-adaptation"
                        ),
                        "transmit-interval" (
                            c(
                                "minimum-interval" arg,
                                "threshold" arg
                            )
                        ),
                        "detection-time" (
                            c(
                                "threshold" arg
                            )
                        ),
                        "authentication" (
                            c(
                                "key-chain" arg,
                                "algorithm" (
                                  ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                ),
                                "loose-check"
                            )
                        )
                    )
                ),
                "family" (("inet" | "inet6")) (
                    c(
                        "bfd-liveness-detection" (
                            c(
                                "version" (
                                  ("0" | "1" | "automatic")
                                ),
                                "minimum-interval" arg,
                                "minimum-transmit-interval" arg,
                                "minimum-receive-interval" arg,
                                "multiplier" arg,
                                c(
                                  "no-adaptation"
                                ),
                                "transmit-interval" (
                                    c(
                                        "minimum-interval" arg,
                                        "threshold" arg
                                    )
                                ),
                                "detection-time" (
                                    c(
                                        "threshold" arg
                                    )
                                ),
                                "authentication" (
                                    c(
                                        "key-chain" arg,
                                        "algorithm" (
                                          ("simple-password" | "keyed-md5" | "meticulous-keyed-md5" | "keyed-sha-1" | "meticulous-keyed-sha-1")
                                        ),
                                        "loose-check"
                                    )
                                )
                            )
                        )
                    )
                ),
                "level" arg (
                    c(
                          ("disable"),
                        "metric" arg,
                        "ipv4-multicast-metric" arg,
                        "ipv6-unicast-metric" arg,
                        "ipv6-multicast-metric" arg,
                        "no-advertise-adjacency-segment",
                        "te-metric" arg,
                        "topology" (("default" | "ipv4-multicast" | "ipv6-unicast" | "ipv6-multicast")) (
                            c(
                                "metric" arg,
                                "bandwidth-based-metrics" (
                                    c(
                                        "bandwidth" arg (
                                            c(
                                                "metric" arg
                                            )
                                        ).as(:oneline)
                                    )
                                )
                            )
                        ),
                        "authentication-key" (
                          unreadable
                        ),
                        "authentication-type" (
                          ("md5" | "simple")
                        ),
                        "hello-authentication-key" (
                          unreadable
                        ),
                        "hello-authentication-type" (
                          ("md5" | "simple")
                        ),
                        "hello-authentication-key-chain" arg,
                        "hello-interval" arg,
                        "hold-time" arg,
                        "priority" arg,
                        "passive" (
                            c(
                                "remote-node-iso" (
                                  sysid
                                ),
                                "remote-node-id" (
                                  ipv4addr
                                )
                            )
                        )
                    )
                ),
                "link-degradation-threshold" (
                    c(
                        "link-down" arg,
                        "link-up" arg
                    )
                ).as(:oneline)
            )
        ),
        "interface-group" arg (
            c(
                "interface" arg,
                "level" arg (
                    c(
                        "topology" (("default" | "ipv4-multicast" | "ipv6-unicast" | "ipv6-multicast")) (
                            c(
                                "metric" arg,
                                "bandwidth-based-metrics" (
                                    c(
                                        "bandwidth" arg (
                                            c(
                                                "metric" arg
                                            )
                                        ).as(:oneline)
                                    )
                                )
                            )
                        )
                    )
                ),
                "link-group-protection" (
                    c(
                        "minimum-bandwidth" arg,
                        "revert-bandwidth" arg
                    )
                )
            )
        ),
        "label-switched-path" arg (
            c(
                "level" arg (
                    c(
                          ("disable"),
                        "metric" arg
                    )
                )
            )
        ),
        "context-identifier" arg (
            c(
                "level" arg (
                    c(
                          ("disable")
                    )
                )
            )
        )
    )
end

rule(:juniper_protocols_l2control) do
    c(
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("parse" | "regex-parse" | "config-internal" | "normal" | "general" | "state" | "task" | "timer" | "ppmlite" | "all")) (
                    c(
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "nonstop-bridging",
        "bpdu-block" (
            c(
                "interface" (arg | "all") (
                    c(
                        "disable",
                        "drop"
                    )
                ),
                "disable-timeout" arg
            )
        ),
        "mac-rewrite" (
            c(
                "interface" arg (
                    c(
                        "enable-all-ifl",
                        "protocol" (
                            c(
                                "stp",
                                "vtp",
                                "cdp",
                                "ieee8021x",
                                "ieee8023ah",
                                "elmi",
                                "lacp",
                                "lldp",
                                "mmrp",
                                "mvrp",
                                "pvstp",
                                "gvrp",
                                "vstp"
                            )
                        )
                    )
                )
            )
        )
    )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:juniper_protocols_protection_group_eaps) do
    c(
          juniper_protocols_protection_group_eaps_profile
    )
end

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

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

rule(:erp_data_channel) do
    c(
        "vlan" arg
    )
end

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

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

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

rule(:juniper_protocols_router_discovery) do
    c(
          ("disable"),
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")).as(:oneline)
            )
        ),
        "interface" arg (
            c(
                "max-advertisement-interval" arg,
                "min-advertisement-interval" arg,
                "lifetime" arg
            )
        ),
        "address" arg (
            c(
                "advertise",
                "ignore",
                "broadcast",
                "multicast",
                "ineligible",
                "priority" arg
            )
        )
    )
end

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

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

rule(:juniper_protocols_vni_options) do
    c(
        "vni" arg (
            c(
                "vrf-target" (
                    c(
                        arg
                    )
                )
            )
        )
    )
end

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

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

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

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

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

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

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

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

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

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

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

rule(:juniper_protocols_evi_options) do
    c(
        "isid" arg (
            c(
                "vrf-target" (
                    c(
                        arg
                    )
                )
            )
        )
    )
end

rule(:juniper_protocols_pim_snooping) do
    c(
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("packets" | "hello" | "join" | "prune" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                    c(
                        "send",
                        "receive",
                        "detail",
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "no-dr-flood",
        "vlan" arg (
            c(
                "no-dr-flood"
            )
        )
    )
end

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

rule(:juniper_ri_protocols_mld_snooping) do
    c(
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("packets" | "query" | "report" | "leave" | "group" | "client-notification" | "host-notification" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")) (
                    c(
                        "send",
                        "receive",
                        "detail",
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "query-interval" arg,
        "query-response-interval" arg,
        "query-last-member-interval" arg,
        "robust-count" arg,
        "immediate-leave",
        "proxy" (
            c(
                "source-address" (
                  ipv6addr
                ),
                "irb"
            )
        ),
        "interface" arg (
            c(
                "multicast-router-interface",
                "immediate-leave",
                "host-only-interface",
                "group-limit" arg,
                "static" (
                    c(
                        "group" arg (
                            c(
                                "source" arg
                            )
                        )
                    )
                )
            )
        ),
        "pseudowire-remote-address" arg (
            c(
                "multicast-router-interface",
                "immediate-leave"
            )
        ),
        "qualified-vlan" arg (
            c(
                "query-interval" arg,
                "query-response-interval" arg,
                "query-last-member-interval" arg,
                "robust-count" arg,
                "immediate-leave",
                "proxy" (
                    c(
                        "source-address" (
                          ipv6addr
                        )
                    )
                ),
                "interface" arg (
                    c(
                        "multicast-router-interface",
                        "immediate-leave",
                        "host-only-interface",
                        "group-limit" arg,
                        "static" (
                            c(
                                "group" arg (
                                    c(
                                        "source" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "pseudowire-remote-address" arg (
                    c(
                        "multicast-router-interface",
                        "immediate-leave"
                    )
                )
            )
        ),
        "vlan" arg (
            c(
                "query-interval" arg,
                "query-response-interval" arg,
                "query-last-member-interval" arg,
                "robust-count" arg,
                "immediate-leave",
                "proxy" (
                    c(
                        "source-address" (
                          ipv6addr
                        )
                    )
                ),
                "interface" arg (
                    c(
                        "multicast-router-interface",
                        "immediate-leave",
                        "host-only-interface",
                        "group-limit" arg,
                        "static" (
                            c(
                                "group" arg (
                                    c(
                                        "source" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "pseudowire-remote-address" arg (
                    c(
                        "multicast-router-interface",
                        "immediate-leave"
                    )
                ),
                "qualified-vlan" arg (
                    c(
                        "query-interval" arg,
                        "query-response-interval" arg,
                        "query-last-member-interval" arg,
                        "robust-count" arg,
                        "immediate-leave",
                        "proxy" (
                            c(
                                "source-address" (
                                  ipv6addr
                                )
                            )
                        ),
                        "interface" arg (
                            c(
                                "multicast-router-interface",
                                "immediate-leave",
                                "host-only-interface",
                                "group-limit" arg,
                                "static" (
                                    c(
                                        "group" arg (
                                            c(
                                                "source" arg
                                            )
                                        )
                                    )
                                )
                            )
                        ),
                        "pseudowire-remote-address" arg (
                            c(
                                "multicast-router-interface",
                                "immediate-leave"
                            )
                        )
                    )
                )
            )
        )
    )
end

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

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

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

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

rule(:dynamic_tunnel_type) do
  arg.as(:arg) (
    c(
        "source-address" (
          ipaddr
        ),
        c(
          "rsvp-te" arg (
              c(
                  "label-switched-path-template" (
                      c(
                          c(
                            arg,
                            "default-template"
                          )
                      )
                  ),
                  "destination-networks" (
                    network_type
                  )
              )
          ),
          "gre",
          "udp"
        ),
        "destination-networks" (
          network_type
        )
    )
  )
end

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

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

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

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

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

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

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

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

rule(:juniper_system) do
    c(
        "configuration-database" (
            c(
                "ephemeral" (
                    c(
                        "instance" arg,
                        "ignore-ephemeral-default",
                        "allow-commit-synchronize-with-gres"
                    )
                ),
                "virtual-memory-mapping" (
                    c(
                        "process" arg (
                            c(
                                "fixed-size" arg,
                                "page-pooling-size" arg,
                                "page-leak-debug"
                            )
                        ),
                        "process-set" (
                            c(
                                "subscriber-management" (
                                    c(
                                        "fixed-size" arg,
                                        "page-pooling-size" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "extend-size",
                "resize" (
                    c(
                        "database-size-on-disk" arg,
                        "database-size-diff" arg
                    )
                ),
                "max-db-size" arg
            )
        ),
        "autoinstallation",
        "host-name" arg,
        "auto-snapshot",
        "unattended-boot",
        "dgasp-int",
        "dgasp-usb",
        "domain-name" arg,
        "domain-search" arg,
        "no-hidden-commands",
        "backup-router" (
            c(
                  ipv4addr,
                "destination" (
                  ipv4prefix
                )
            )
        ).as(:oneline),
        "inet6-backup-router" (
            c(
                  ipv6addr,
                "destination" (
                  ipv6prefix
                )
            )
        ).as(:oneline),
        "time-zone" arg,
        "use-imported-time-zones",
        "regex-additive-logic",
        "switchover-on-routing-crash",
        "network-stack-in-jlock-shared-mode",
        "default-address-selection",
        "nd-maxmcast-solicit" arg,
        "nd-maxucast-retry" arg,
        "nd-retransmit-timer" arg,
        "nd-system-cache-limit" arg,
        "arp-system-cache-limit" arg,
        "no-neighbor-learn",
        "no-multicast-echo",
        "no-redirects",
        "no-redirects-ipv6",
        "nd-override-preferred-src",
        "no-ping-record-route",
        "no-ping-time-stamp",
        "dump-device" (
          (arg | "boot-device" | "usb" | "compact-flash" | "removable-compact-flash")
        ),
        "arp" (
            c(
                "aging-timer" arg,
                "interfaces" (
                    c(
                          arp_interface_type
                    )
                ),
                "passive-learning",
                "purging",
                "gratuitous-arp-on-ifup",
                "gratuitous-arp-delay" arg,
                "non-subscriber-no-reply"
            )
        ),
        "personality-file-list-of-directories" arg,
        "saved-core-files" arg,
        "saved-core-context",
        "no-saved-core-context",
        "kernel-replication" (
            c(
                "system-reboot" (
                  ("recovery-failure")
                ),
                "no-multithreading"
            )
        ),
        "mirror-flash-on-disk",
        "icmp-rate-limit" (
            c(
                "packet-rate" arg,
                "bucket-size" arg
            )
        ).as(:oneline),
        "tcp-ack-rst-syn",
        "management-instance",
        "internet-options" (
            c(
                "icmpv4-rate-limit" (
                    c(
                        "packet-rate" arg,
                        "bucket-size" arg
                    )
                ).as(:oneline),
                "icmpv6-rate-limit" (
                    c(
                        "packet-rate" arg,
                        "bucket-size" arg
                    )
                ).as(:oneline),
                "path-mtu-discovery",
                "no-path-mtu-discovery",
                "gre-path-mtu-discovery",
                "no-gre-path-mtu-discovery",
                "ipip-path-mtu-discovery",
                "no-ipip-path-mtu-discovery",
                "source-port" (
                    c(
                        "upper-limit" arg
                    )
                ),
                "source-quench",
                "no-source-quench",
                "tcp-mss" arg,
                "tcp-drop-synfin-set",
                "no-tcp-rfc1323",
                "no-tcp-rfc1323-paws",
                "ipv6-reject-zero-hop-limit",
                "no-ipv6-reject-zero-hop-limit",
                "ipv6-duplicate-addr-detection-transmits" arg,
                "ipv6-path-mtu-discovery",
                "no-ipv6-path-mtu-discovery",
                "ipv6-path-mtu-discovery-timeout" arg,
                "no-tcp-reset" (
                  ("drop-tcp-with-syn-only" | "drop-all-tcp")
                )
            )
        ),
        "authentication-order" (
          ("radius" | "tacplus" | "password")
        ),
        "location" (
          location_type
        ),
        "ports" (
            c(
                "console" (
                  tty_port_object
                ),
                "auxiliary" (
                  tty_port_object
                )
            )
        ),
        "diag-port-authentication" (
            c(
                "plain-text-password-value" arg,
                "encrypted-password" arg
            )
        ),
        "pic-console-authentication" (
            c(
                "plain-text-password-value" arg,
                "encrypted-password" arg
            )
        ),
        "root-authentication" (
          authentication_object
        ),
        "boot-loader-authentication" (
            c(
                "plain-text-password-value" arg,
                "encrypted-password" arg
            )
        ),
        "name-server" (
          nameserver_object
        ),
        "radius-server" (
          radius_server_object
        ),
        "dynamic-profile-options" (
          dynamic_profile_option_object
        ),
        "tacplus-server" (
          tacplus_server_object
        ),
        "radius-options" (
            c(
                "password-protocol" (
                  ("mschap-v2")
                ),
                "enhanced-accounting",
                "attributes" (
                    c(
                        "nas-ip-address" (
                          ipaddr
                        )
                    )
                )
            )
        ),
        "tacplus-options" (
            c(
                "service-name" arg,
                "strict-authorization",
                "no-strict-authorization",
                c(
                  "no-cmd-attribute-value",
                  "exclude-cmd-attribute"
                ),
                "enhanced-accounting",
                "timestamp-and-timezone"
            )
        ),
        "accounting" (
            c(
                "events" (
                  ("login" | "change-log" | "interactive-commands")
                ),
                "enhanced-avs-max" arg,
                "traceoptions" (
                    c(
                        "no-remote-trace",
                        "file" (
                            c(
                                  arg,
                                "size" arg,
                                "files" arg,
                                "world-readable",
                                "no-world-readable"
                            )
                        ).as(:oneline),
                        "flag" (("all" | "events" | "config" | "radius" | "tacplus")).as(:oneline)
                    )
                ),
                "destination" (
                    c(
                        "radius" (
                            c(
                                "server" (
                                  radius_server_object
                                )
                            )
                        ),
                        "tacplus" (
                            c(
                                "server" (
                                  tacplus_server_object
                                )
                            )
                        )
                    )
                )
            )
        ),
        "allow-v4mapped-packets",
        "allow-6pe-traceroute",
        "donot-disable-ip6op-ondad",
        "scripts" (
          scripts_type
        ),
        "login" (
            c(
                "announcement" arg,
                "message" arg,
                "retry-options" (
                    c(
                        "tries-before-disconnect" arg,
                        "backoff-threshold" arg,
                        "backoff-factor" arg,
                        "minimum-time" arg,
                        "maximum-time" arg,
                        "lockout-period" arg
                    )
                ),
                "idle-timeout" arg,
                "class" (
                  login_class_object
                ),
                "user" (
                  login_user_object
                ),
                "password" (
                    c(
                        "minimum-length" arg,
                        "maximum-length" arg,
                        "change-type" (
                          ("character-sets" | "set-transitions")
                        ),
                        "minimum-changes" arg,
                        "minimum-numerics" arg,
                        "minimum-upper-cases" arg,
                        "minimum-lower-cases" arg,
                        "minimum-punctuations" arg,
                        "format" (
                          ("sha1" | "sha256" | "sha512" | "md5" | "des")
                        )
                    )
                ),
                "deny-sources" (
                    c(
                        "address" (
                          ipprefix_optional
                        )
                    )
                )
            )
        ),
        "static-host-mapping" arg (
            c(
                "inet" (
                  ipv4addr
                ),
                "inet6" (
                  ipv6addr
                ),
                "sysid" (
                  sysid
                ),
                "alias" arg
            )
        ),
        "services" (
            c(
                "finger" (
                    c(
                        "connection-limit" arg,
                        "rate-limit" arg
                    )
                ),
                "ftp" (
                    c(
                        "connection-limit" arg,
                        "rate-limit" arg,
                        "authentication-order" (
                          ("radius" | "tacplus" | "password")
                        )
                    )
                ),
                "ssh" (
                    c(
                        "authentication-order" (
                          ("radius" | "tacplus" | "password")
                        ),
                        "root-login" (
                          ("allow" | "deny" | "deny-password")
                        ),
                        "no-passwords",
                        "no-public-keys",
                        c(
                          "tcp-forwarding",
                          "no-tcp-forwarding"
                        ),
                        "protocol-version" (
                          ("v1" | "v2")
                        ),
                        "max-sessions-per-connection" arg,
                        "max-pre-authentication-packets" arg,
                        "ciphers" (
                          ("3des-cbc" | "aes128-cbc" | "aes192-cbc" | "aes256-cbc" | "aes128-ctr" | "aes192-ctr" | "aes256-ctr" | "aes128-gcm@openssh.com" | "aes256-gcm@openssh.com" | "chacha20-poly1305@openssh.com" | "arcfour128" | "arcfour256" | "arcfour" | "blowfish-cbc" | "cast128-cbc")
                        ),
                        "macs" (
                          ("hmac-md5" | "hmac-md5-etm@openssh.com" | "hmac-sha1" | "hmac-sha1-etm@openssh.com" | "umac-64@openssh.com" | "umac-128@openssh.com" | "umac-64-etm@openssh.com" | "umac-128-etm@openssh.com" | "hmac-sha2-256" | "hmac-sha2-256-etm@openssh.com" | "hmac-sha2-256-96" | "hmac-sha2-512" | "hmac-sha2-512-etm@openssh.com" | "hmac-sha2-512-96" | "hmac-ripemd160" | "hmac-ripemd160-etm@openssh.com" | "hmac-sha1-96" | "hmac-sha1-96-etm@openssh.com" | "hmac-md5-96" | "hmac-md5-96-etm@openssh.com")
                        ),
                        "key-exchange" (
                          ("curve25519-sha256" | "ecdh-sha2-nistp256" | "ecdh-sha2-nistp384" | "ecdh-sha2-nistp521" | "group-exchange-sha2" | "group-exchange-sha1" | "dh-group14-sha1" | "dh-group1-sha1")
                        ),
                        "client-alive-count-max" arg,
                        "client-alive-interval" arg,
                        "hostkey-algorithm" (
                            c(
                                c(
                                  "no-ssh-dss",
                                  "ssh-dss" (
                                      c(
                                          c(
                                            "allow",
                                            "deny"
                                          )
                                      )
                                  )
                                ),
                                c(
                                  "no-ssh-rsa",
                                  "ssh-rsa" (
                                      c(
                                          c(
                                            "allow",
                                            "deny"
                                          )
                                      )
                                  )
                                ),
                                c(
                                  "no-ssh-ecdsa",
                                  "ssh-ecdsa" (
                                      c(
                                          c(
                                            "allow",
                                            "deny"
                                          )
                                      )
                                  )
                                ),
                                c(
                                  "no-ssh-ed25519",
                                  "ssh-ed25519"
                                )
                            )
                        ),
                        "fingerprint-hash" (
                          ("sha2-256" | "md5")
                        ),
                        "authorized-keys-command" arg,
                        "authorized-keys-command-user" arg,
                        "connection-limit" arg,
                        "rate-limit" arg
                    )
                ),
                "telnet" (
                    c(
                        "connection-limit" arg,
                        "rate-limit" arg,
                        "authentication-order" (
                          ("radius" | "tacplus" | "password")
                        )
                    )
                ),
                "xnm-clear-text" (
                    c(
                        "connection-limit" arg,
                        "rate-limit" arg
                    )
                ),
                "xnm-ssl" (
                    c(
                        "local-certificate" arg,
                        "ssl-renegotiation",
                        "no-ssl-renegotiation",
                        "connection-limit" arg,
                        "rate-limit" arg
                    )
                ),
                "extension-service" (
                    c(
                        "request-response" (
                            c(
                                "grpc" (
                                    c(
                                        c(
                                          "ssl" (
                                              c(
                                                  "address" (
                                                    ipaddr
                                                  ),
                                                  "port" arg,
                                                  "local-certificate" arg
                                              )
                                          )
                                        ),
                                        "max-connections" arg,
                                        "scripts" (
                                            c(
                                                "file" (
                                                  jet_scripts_file_type
                                                )
                                            )
                                        ),
                                        "clear-text" (
                                            c(
                                                "address" ipaddr,
                                                "port" arg
                                            )
                                        ),
                                        "skip-authentication"
                                    )
                                )
                            )
                        ),
                        "notification" (
                            c(
                                "port" arg,
                                "max-connections" arg,
                                "broker-socket-send-buffer-size" arg,
                                "allow-clients" (
                                    c(
                                        "address" (
                                          ipprefix_optional
                                        )
                                    )
                                )
                            )
                        ),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "flag" (("timer" | "timeouts" | "routing-socket" | "general" | "config" | "grpc" | "notification" | "all")).as(:oneline)
                            )
                        )
                    )
                ),
                "netconf" (
                    c(
                        "ssh" (
                            c(
                                "connection-limit" arg,
                                "rate-limit" arg,
                                "port" arg
                            )
                        ),
                        "rfc-compliant",
                        "yang-compliant",
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "flag" (("all" | "incoming" | "outgoing" | "debug")).as(:oneline),
                                "on-demand"
                            )
                        )
                    )
                ),
                "tftp-server" (
                    c(
                        "connection-limit" arg,
                        "rate-limit" arg
                    )
                ),
                "flow-tap-dtcp" (
                    c(
                        "ssh" (
                            c(
                                "connection-limit" arg,
                                "rate-limit" arg
                            )
                        )
                    )
                ),
                "reverse" (
                    c(
                        "telnet" (
                            c(
                                "port" arg
                            )
                        ),
                        "ssh" (
                            c(
                                "port" arg
                            )
                        )
                    )
                ),
                "dns" (
                    c(
                        "max-cache-ttl" arg,
                        "max-ncache-ttl" arg,
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable"
                                    )
                                ).as(:oneline),
                                "debug-level" arg,
                                "category" ("default" | "general" | "database" | "security" | "config" | "resolver" | "xfer-in" | "xfer-out" | "notify" | "client" | "unmatched" | "network" | "update" | "update-security" | "queries" | "dispatch" | "dnssec" | "lame-servers" | "delegation-only" | "edns-disabled").as(:oneline)
                            )
                        ),
                        "forwarders" arg,
                        "dnssec" (
                            c(
                                "disable",
                                "trusted-keys" (
                                    c(
                                        "key" arg
                                    )
                                ),
                                "dlv" (
                                    s(
                                      "domain" arg,
                                      "trusted-anchor" arg
                                    )
                                ).as(:oneline),
                                "secure-domains" arg
                            )
                        )
                    )
                ),
                "service-deployment" (
                    c(
                        "local-certificate" arg,
                        "source-address" (
                          ipv4addr
                        ),
                        "servers" arg (
                            c(
                                "port" arg,
                                "user" arg,
                                "security-options" (
                                    c(
                                        c(
                                          "tls",
                                          "ssl3"
                                        )
                                    )
                                )
                            )
                        ),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "flag" (("beep" | "profile" | "application" | "io" | "all")).as(:oneline)
                            )
                        )
                    )
                ),
                "outbound-ssh" (
                    c(
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "flag" (("configuration" | "connectivity" | "all")).as(:oneline)
                            )
                        ),
                        "client" arg (
                            c(
                                "disable-ssh-security-settings",
                                "device-id" arg,
                                "secret" (
                                  unreadable
                                ),
                                "keep-alive" (
                                    c(
                                        "retry" arg,
                                        "timeout" arg
                                    )
                                ),
                                "reconnect-strategy" (
                                  ("sticky" | "in-order")
                                ),
                                "services" (
                                  ("netconf")
                                ),
                                    c(
                                        "port" arg,
                                        "retry" arg,
                                        "timeout" arg
                                    )
                            )
                        )
                    )
                ),
                "rest" (
                    c(
                        "http" (
                            c(
                                "port" arg,
                                "addresses" (
                                  ipv4addr
                                )
                            )
                        ),
                        "https" (
                            c(
                                "port" arg,
                                "addresses" (
                                  ipv4addr
                                ),
                                "server-certificate" arg,
                                "cipher-list" (
                                  ("rsa-with-rc4-128-md5" | "rsa-with-rc4-128-sha" | "rsa-with-3des-ede-cbc-sha" | "dhe-rsa-with-3des-ede-cbc-sha" | "rsa-with-aes-128-cbc-sha" | "dhe-rsa-with-aes-128-cbc-sha" | "rsa-with-aes-256-cbc-sha" | "dhe-rsa-with-aes-256-cbc-sha" | "ecdhe-rsa-with-rc4-128-sha" | "ecdhe-rsa-with-3des-ede-cbc-sha" | "ecdhe-rsa-with-aes-128-cbc-sha" | "ecdhe-rsa-with-aes-256-cbc-sha" | "rsa-with-aes-128-cbc-sha256" | "rsa-with-aes-256-cbc-sha256" | "dhe-rsa-with-aes-128-cbc-sha256" | "dhe-rsa-with-aes-256-cbc-sha256" | "rsa-with-aes-128-gcm-sha256" | "rsa-with-aes-256-gcm-sha384" | "dhe-rsa-with-aes-128-gcm-sha256" | "dhe-rsa-with-aes-256-gcm-sha384" | "ecdhe-rsa-with-aes-128-cbc-sha256" | "ecdhe-rsa-with-aes-256-cbc-sha384" | "ecdhe-rsa-with-aes-128-gcm-sha256" | "ecdhe-rsa-with-aes-256-gcm-sha384")
                                ),
                                "mutual-authentication" (
                                    c(
                                        "certificate-authority" arg
                                    )
                                )
                            )
                        ),
                        "control" (
                            c(
                                "allowed-sources" (
                                  ipv4addr
                                ),
                                "connection-limit" arg
                            )
                        ),
                        "traceoptions" (
                            c(
                                "flag" (
                                  ("lighttpd" | "juise" | "all")
                                )
                            )
                        ),
                        "enable-explorer"
                    )
                ),
                "subscriber-management-helper" (
                  smihelperd_type
                ),
                "dhcp-local-server" (
                  jdhcp_local_server_type
                ),
                "dhcp-proxy-client" (
                  jdhcp_proxy_client_type
                ),
                "database-replication" (
                  bdbrepd_type
                ),
                "web-management" (
                    c(
                        "traceoptions" (
                          httpd_traceoptions_type
                        ),
                        "management-url" arg,
                        "http" (
                            c(
                                "port" arg,
                                "interface" (
                                  interface_name
                                )
                            )
                        ),
                        "https" (
                            c(
                                "port" arg,
                                c(
                                  "local-certificate" arg,
                                  "pki-local-certificate" arg,
                                  "system-generated-certificate"
                                ),
                                "interface" (
                                  interface_name
                                )
                            )
                        ),
                        "control" (
                            c(
                                "max-threads" arg
                            )
                        ),
                        "session" (
                            c(
                                "idle-timeout" arg,
                                "session-limit" arg
                            )
                        )
                    )
                ),
                "packet-triggered-subscribers" (
                    c(
                        "subscriber-idle-timeout" arg,
                        "subscriber-packet-idle-timeout" arg,
                        "traceoptions" (
                          jptspd_traceoptions_type
                        ),
                        "partition" arg (
                            c(
                                "diameter-instance" arg,
                                "destination-realm" arg,
                                "destination-host" arg
                            )
                        ),
                        "partition-diameter-jgx" arg (
                            c(
                                "diameter-instance" arg,
                                "destination-realm" arg,
                                "destination-host" arg
                            )
                        ),
                        "partition-radius" arg (
                            c(
                                "accounting-port" arg,
                                "accounting-shared-secret" (
                                  unreadable
                                ),
                                "accounting-mode" (
                                  ("reply" | "no-reply")
                                ),
                                "routing-instance" arg,
                                "accounting-ip-address" (
                                  ipaddr
                                ),
                                "pre-announcement" arg,
                                "accounting-attribute-type" arg,
                                "accounting-vendor-id" arg,
                                "subscriber-service-profile" arg,
                                "subscriber-identification" arg
                            )
                        ),
                        "subscriber-profile" arg (
                            c(
                                "enable" arg (
                                    c(
                                        "concurrent-data-sessions" arg
                                    )
                                ),
                                "disable" arg,
                                "max-data-sessions-per-subscriber" (
                                    c(
                                        "limit" arg,
                                        "exceed-action" (
                                          ("drop" | "syslog")
                                        )
                                    )
                                )
                            )
                        )
                    )
                ),
                "static-subscribers" (
                  jsscd_static_subscribers_type
                ),
                "subscriber-management" (
                  smid_type
                ),
                "resource-monitor" (
                  resource_monitor_type
                ),
                "extensible-subscriber-services" (
                    c(
                        "maximum-subscribers" (
                            c(
                                  arg
                            )
                        ),
                        "commit-interval" (
                            c(
                                  arg
                            )
                        ),
                        "flat-file-accounting-interval" (
                            c(
                                  arg
                            )
                        ),
                        "flat-file-rollover-interval" (
                            c(
                                  arg
                            )
                        ),
                        "logical-interface-unit-range" (
                            c(
                                "low" arg,
                                "high" arg
                            )
                        ),
                        "dictionary" (
                            c(
                                  filename
                            )
                        ),
                        "flat-file-accounting-format" (
                            c(
                                c(
                                  "ipdr",
                                  "csv"
                                )
                            )
                        ),
                        "access-profile" (
                            c(
                                  arg
                            )
                        ),
                        "flat-file-profile" arg
                    )
                ),
                "dhcp" (
                    c(
                        "maximum-lease-time" (
                          ("infinite" | arg)
                        ),
                        "default-lease-time" (
                          ("infinite" | arg)
                        ),
                        "domain-name" arg,
                        "name-server" arg,
                        "domain-search" arg,
                        "wins-server" arg,
                        "router" arg,
                        "boot-file" arg,
                        "boot-server" arg,
                        "next-server" (
                          ipv4addr
                        ),
                        "server-identifier" (
                          ipv4addr
                        ),
                        "option" arg (
                            c(
                                c(
                                  "flag" (
                                    ("true" | "false" | "on" | "off")
                                  ),
                                  "byte" arg,
                                  "short" arg,
                                  "unsigned-short" arg,
                                  "integer" arg,
                                  "unsigned-integer" arg,
                                  "string" arg,
                                  "ip-address" (
                                    ipv4addr
                                  ),
                                  "array" (
                                      c(
                                          c(
                                            "flag" (
                                              ("true" | "false" | "on" | "off")
                                            ),
                                            "byte" arg,
                                            "short" arg,
                                            "unsigned-short" arg,
                                            "integer" arg,
                                            "unsigned-integer" arg,
                                            "string" arg,
                                            "ip-address" (
                                              ipv4addr
                                            )
                                          )
                                      )
                                  ),
                                  "byte-stream" arg
                                )
                            )
                        ).as(:oneline),
                        "sip-server" (
                            c(
                                "name" arg,
                                "address" arg
                            )
                        ),
                        "traceoptions" (
                          dhcp_traceoptions_type
                        ),
                        "pool" arg (
                            c(
                                "address-range" (
                                    c(
                                        "low" (
                                          ipv4addr
                                        ),
                                        "high" (
                                          ipv4addr
                                        )
                                    )
                                ).as(:oneline),
                                "exclude-address" arg,
                                "maximum-lease-time" (
                                  ("infinite" | arg)
                                ),
                                "default-lease-time" (
                                  ("infinite" | arg)
                                ),
                                "domain-name" arg,
                                "name-server" arg,
                                "domain-search" arg,
                                "wins-server" arg,
                                "router" arg,
                                "boot-file" arg,
                                "boot-server" arg,
                                "next-server" (
                                  ipv4addr
                                ),
                                "server-identifier" (
                                  ipv4addr
                                ),
                                "option" arg (
                                    c(
                                        c(
                                          "flag" (
                                            ("true" | "false" | "on" | "off")
                                          ),
                                          "byte" arg,
                                          "short" arg,
                                          "unsigned-short" arg,
                                          "integer" arg,
                                          "unsigned-integer" arg,
                                          "string" arg,
                                          "ip-address" (
                                            ipv4addr
                                          ),
                                          "array" (
                                              c(
                                                  c(
                                                    "flag" (
                                                      ("true" | "false" | "on" | "off")
                                                    ),
                                                    "byte" arg,
                                                    "short" arg,
                                                    "unsigned-short" arg,
                                                    "integer" arg,
                                                    "unsigned-integer" arg,
                                                    "string" arg,
                                                    "ip-address" (
                                                      ipv4addr
                                                    )
                                                  )
                                              )
                                          ),
                                          "byte-stream" arg
                                        )
                                    )
                                ).as(:oneline),
                                "sip-server" (
                                    c(
                                        "name" arg,
                                        "address" arg
                                    )
                                )
                            )
                        ),
                        "static-binding" arg (
                            c(
                                "fixed-address" arg,
                                "host-name" arg,
                                "client-identifier" (
                                    c(
                                        c(
                                          "ascii" arg,
                                          "hexadecimal" arg
                                        )
                                    )
                                ).as(:oneline),
                                "domain-name" arg,
                                "name-server" arg,
                                "domain-search" arg,
                                "wins-server" arg,
                                "router" arg,
                                "boot-file" arg,
                                "boot-server" arg,
                                "next-server" (
                                  ipv4addr
                                ),
                                "server-identifier" (
                                  ipv4addr
                                ),
                                "option" arg (
                                    c(
                                        c(
                                          "flag" (
                                            ("true" | "false" | "on" | "off")
                                          ),
                                          "byte" arg,
                                          "short" arg,
                                          "unsigned-short" arg,
                                          "integer" arg,
                                          "unsigned-integer" arg,
                                          "string" arg,
                                          "ip-address" (
                                            ipv4addr
                                          ),
                                          "array" (
                                              c(
                                                  c(
                                                    "flag" (
                                                      ("true" | "false" | "on" | "off")
                                                    ),
                                                    "byte" arg,
                                                    "short" arg,
                                                    "unsigned-short" arg,
                                                    "integer" arg,
                                                    "unsigned-integer" arg,
                                                    "string" arg,
                                                    "ip-address" (
                                                      ipv4addr
                                                    )
                                                  )
                                              )
                                          ),
                                          "byte-stream" arg
                                        )
                                    )
                                ).as(:oneline),
                                "sip-server" (
                                    c(
                                        "name" arg,
                                        "address" arg
                                    )
                                )
                            )
                        )
                    )
                ),
                "transport"
            )
        ),
        "syslog" (
            c(
                "archive" (
                  archive_object
                ),
                "user" arg (
                    c(
                          syslog_object.as(:oneline),
                        "match" (
                          regular_expression
                        ),
                        "allow-duplicates",
                        "match-strings" arg
                    )
                ),
                "host" ("other-routing-engine" | "scc-master" | "sfc0-master" | arg) (
                    c(
                          syslog_object.as(:oneline),
                        "match" (
                          regular_expression
                        ),
                        "allow-duplicates",
                        "port" arg,
                        "facility-override" (
                          ("authorization" | "daemon" | "ftp" | "kernel" | "user" | "local0" | "local1" | "local2" | "local3" | "local4" | "local5" | "local6" | "local7")
                        ),
                        "log-prefix" arg,
                        "source-address" (
                          ipaddr
                        ),
                        "explicit-priority",
                        "exclude-hostname",
                        "match-strings" arg,
                        "structured-data" (
                            c(
                                c(
                                  "brief"
                                )
                            )
                        )
                    )
                ),
                "allow-duplicates",
                "file" arg (
                    c(
                          syslog_object.as(:oneline),
                        "match" (
                          regular_expression
                        ),
                        "allow-duplicates",
                        "archive" (
                          archive_object
                        ),
                        "explicit-priority",
                        "match-strings" arg,
                        "structured-data" (
                            c(
                                c(
                                  "brief"
                                )
                            )
                        )
                    )
                ),
                "console" (("any" | "authorization" | "daemon" | "ftp" | "ntp" | "security" | "kernel" | "user" | "dfc" | "external" | "firewall" | "pfe" | "conflict-log" | "change-log" | "interactive-commands")) (
                    c(
                        c(
                          "any",
                          "emergency",
                          "alert",
                          "critical",
                          "error",
                          "warning",
                          "notice",
                          "info",
                          "none"
                        )
                    )
                ).as(:oneline),
                "time-format" (
                    c(
                        "year",
                        "millisecond"
                    )
                ).as(:oneline),
                "source-address" (
                  ipaddr
                ),
                "log-rotate-frequency" arg,
                "server" (
                    c(
                        "routing-instances" ("all" | "default" | arg) (
                            c(
                                "disable"
                            )
                        )
                    )
                )
            )
        ),
        "tracing" (
            c(
                "destination-override" (
                    c(
                        "syslog" (
                            c(
                                "host" (
                                  ipv4addr
                                )
                            )
                        ).as(:oneline)
                    )
                ).as(:oneline)
            )
        ).as(:oneline),
        "encrypt-configuration-files",
        "compress-configuration-files",
        "no-compress-configuration-files",
        "max-configurations-on-flash" arg,
        "max-configuration-rollbacks" arg,
        "archival" (
            c(
                "configuration" (
                    c(
                        c(
                          "transfer-interval" arg,
                          "transfer-on-commit"
                        ),
                        "archive-sites" arg (
                            c(
                                "password" (
                                  unreadable
                                )
                            )
                        ).as(:oneline)
                    )
                )
            )
        ),
        "extensions" (
            c(
                "providers" arg (
                    c(
                        "license-type" arg (
                            c(
                                "deployment-scope" arg
                            )
                        ).as(:oneline)
                    )
                ),
                "extension-service" (
                    c(
                        "application" (
                            c(
                                "file" (
                                  jet_scripts_file_type
                                ),
                                "traceoptions" (
                                  script_traceoptions
                                ),
                                "max-datasize" arg
                            )
                        )
                    )
                ),
                "resource-limits" (
                    c(
                        "process" arg (
                            c(
                                "resources" (
                                  resources_type
                                )
                            )
                        ),
                        "package" arg (
                            c(
                                "resources" (
                                  resources_type
                                )
                            )
                        )
                    )
                )
            )
        ),
        "license" (
          license_object
        ),
        "proxy" (
          proxy_object
        ),
        "commit" (
            c(
                "notification",
                "fast-synchronize",
                "synchronize",
                "peers-synchronize",
                "delta-export",
                "peers" (
                  peers_type
                ),
                "commit-synchronize-server" (
                    c(
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "microsecond-stamp"
                                    )
                                ).as(:oneline),
                                "flag" (("ephemeral-commit" | "operational-command" | "debug" | "all")).as(:oneline)
                            )
                        )
                    )
                ),
                "server" (
                    c(
                        "maximum-aggregate-pool" arg,
                        "maximum-entries" arg,
                        "commit-interval" arg,
                        "retry-attempts" arg,
                        "retry-interval" arg,
                        "days-to-keep-error-logs" arg,
                        "redirect-completion-status" arg,
                        "commit-schedule-profile" arg (
                            c(
                                "start-time" arg,
                                "end-time" arg,
                                "interruptible",
                                "load-average" (
                                  unsigned_float
                                )
                            )
                        ),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "microsecond-stamp"
                                    )
                                ).as(:oneline),
                                "flag" (("all" | "commit-server" | "batch" | "configuration")).as(:oneline)
                            )
                        )
                    )
                ),
                "persist-groups-inheritance"
            )
        ),
        "fips" (
            c(
                "level" arg,
                "self-test" (
                    c(
                        "after-key-generation" (
                          ("enable" | "disable")
                        ),
                        "periodic" (
                            c(
                                "start-time" arg,
                                "day-of-month" arg,
                                "month" arg,
                                "day-of-week" arg
                            )
                        )
                    )
                )
            )
        ),
        "export-format" (
            c(
                "json" (
                    c(
                        c(
                          "verbose",
                          "ietf"
                        )
                    )
                )
            )
        ),
        "health-monitor" (
            c(
                "ifstate-clients" (
                    c(
                        "peer-stuck" (
                            c(
                                "threshold-level" (
                                  ("low" | "medium" | "high")
                                ),
                                "action" (
                                  ("alarm" | "alarm-with-cores" | "restart")
                                )
                            )
                        ),
                        "non-peer-stuck" (
                            c(
                                "threshold-level" (
                                  ("low" | "medium" | "high")
                                ),
                                "action" (
                                  ("alarm" | "alarm-with-cores" | "restart")
                                )
                            )
                        ),
                        "all-clients-stuck" (
                            c(
                                "threshold-level" (
                                  ("low" | "medium" | "high")
                                ),
                                "action" (
                                  ("alarm" | "alarm-with-cores" | "restart")
                                )
                            )
                        )
                    )
                )
            )
        ),
        "auto-configuration" (
            c(
                "traceoptions" (
                  autoconf_traceoptions_type
                )
            )
        ),
        "processes" (
            c(
                "routing" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        ),
                        c(
                          "force-32-bit",
                          "force-64-bit",
                          "auto-64-bit"
                        )
                    )
                ).as(:oneline),
                "software-forwarding" (
                    c(
                          ("disable")
                    )
                ).as(:oneline),
                "packet-forwarding-engine" (
                    c(
                          ("disable")
                    )
                ).as(:oneline),
                "chassis-control" (
                    c(
                          ("disable"),
                        "failover" (
                          ("alternate-media")
                        )
                    )
                ).as(:oneline),
                "service-pics" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        )
                    )
                ).as(:oneline),
                "ntp" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        )
                    )
                ).as(:oneline),
                "watchdog" (
                    c(
                          ("enable" | "disable"),
                        "timeout" arg
                    )
                ).as(:oneline),
                "process-monitor" (
                    c(
                          ("disable"),
                        "traceoptions" (
                          pmond_traceoptions_type
                        )
                    )
                ),
                "resource-cleanup" (
                    c(
                          ("disable"),
                        "traceoptions" (
                          res_cleanupd_traceoptions_type
                        )
                    )
                ),
                "routing-socket-proxy" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        )
                    )
                ).as(:oneline),
                "web-management" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        )
                    )
                ).as(:oneline),
                "named-service" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        )
                    )
                ),
                "cfm" (
                    c(
                          ("disable")
                    )
                ).as(:oneline),
                "general-authentication-service" (
                    c(
                          ("disable"),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "filter" (
                                    c(
                                        "user" (
                                            c(
                                                  arg
                                            )
                                        )
                                    )
                                ),
                                "flag" (("configuration" | "framework" | "radius" | "local-authentication" | "ldap" | "address-assignment" | "jsrc" | "gx-plus" | "session-db" | "profile-db" | "lib-stats" | "user-access" | "nasreq" | "all")).as(:oneline)
                            )
                        )
                    )
                ),
                "smg-service" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        ),
                        "traceoptions" (
                          bbe_smgd_traceoptions_type
                        )
                    )
                ),
                "bbe-mib-daemon" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        ),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "level" (
                                  ("error" | "warning" | "notice" | "info" | "verbose" | "all")
                                ),
                                "flag" (("framework" | "all")).as(:oneline)
                            )
                        )
                    )
                ),
                "dhcp-service" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        ),
                        "persistent-storage" (
                            c(
                                  arg,
                                "backup-interval" arg
                            )
                        ),
                        "traceoptions" (
                          jdhcp_traceoptions_level_type
                        ),
                        "interface-traceoptions" (
                          jdhcp_interface_traceoptions_level_type
                        ),
                        "dhcp-snooping-file" (
                            c(
                                  filename,
                                "write-interval" arg
                            )
                        ),
                        "dhcpv6-snooping-file" (
                            c(
                                  filename,
                                "write-interval" arg
                            )
                        ),
                        "ltv-syslog-interval" (
                            c(
                                  arg
                            )
                        ),
                        "accept-max-tcp-connections" arg,
                        "request-max-tcp-connections" arg
                    )
                ),
                "diameter-service" (
                    c(
                          ("disable"),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "level" (
                                  ("error" | "warning" | "notice" | "info" | "verbose" | "all")
                                ),
                                "flag" (("framework" | "configuration" | "memory-management" | "daemon" | "application" | "node" | "diameter-instance" | "dne" | "peer" | "messages" | "all")).as(:oneline)
                            )
                        )
                    )
                ),
                "mac-validation" (
                    c(
                          ("disable"),
                        "traceoptions" (
                          jsavald_traceoptions_type
                        )
                    )
                ),
                "sbc-configuration-process" (
                    c(
                          ("disable"),
                        "failover" (
                          ("other-routing-engine" | "alternate-media")
                        ),
                        "traceoptions" (
                          sbc_traceoptions
                        )
                    )
                ),
                "sdk-service" (
                    c(
                          ("disable"),
                        "traceoptions" (
                          ssd_traceoptions_type
                        )
                    )
                ),
                "app-engine-virtual-machine-management-service" (
                    c(
                          ("disable"),
                        "traceoptions" (
                          sdk_vmmd_traceoptions_type
                        )
                    )
                ),
                "app-engine-management-service" (
                    c(
                          ("disable"),
                        "traceoptions" (
                          sdk_mgmtd_traceoptions_type
                        )
                    )
                ),
                "datapath-trace-service" (
                    c(
                          ("disable"),
                        "traceoptions" (
                          datapath_traced_traceoptions_type
                        )
                    )
                ),
                "send" (
                    c(
                          ("disable")
                    )
                ).as(:oneline),
                "static-subscribers" (
                    c(
                          ("disable"),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline),
                                "level" (
                                  ("error" | "warning" | "notice" | "info" | "verbose" | "all")
                                ),
                                "flag" (("configuration" | "database" | "general" | "message" | "rtsock" | "statistics" | "subscriber" | "gres" | "issu" | "authentication" | "profile" | "all")).as(:oneline)
                            )
                        )
                    )
                ),
                "extensible-subscriber-services" (
                    c(
                          ("disable"),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        ),
                                        "microsecond-stamp"
                                    )
                                ).as(:oneline),
                                "level" (
                                  ("error" | "warning" | "notice" | "info" | "verbose" | "all")
                                ),
                                "flag" (("authentication" | "configuration" | "database" | "dictionary" | "dynamic" | "fsm" | "general" | "kernel" | "op-script" | "statistics" | "all")).as(:oneline)
                            )
                        )
                    )
                ),
                "kernel-offload-service" (
                    c(
                          ("disable"),
                        "traceoptions" (
                          kod_trace_type
                        )
                    )
                ),
                  daemon_process,
                "video-monitoring" (
                    c(
                          ("disable"),
                        "traceoptions" (
                            c(
                                "no-remote-trace",
                                "file" (
                                    c(
                                          arg,
                                        "size" arg,
                                        "files" arg,
                                        "world-readable",
                                        "no-world-readable",
                                        "match" (
                                          regular_expression
                                        )
                                    )
                                ).as(:oneline)
                            )
                        )
                    )
                ).as(:oneline)
            )
        ),
        "ddos-protection" (
            c(
                "traceoptions" (
                  ddos_traceoptions_type
                ),
                "global" (
                    c(
                        "disable-routing-engine",
                        "disable-fpc",
                        "disable-logging",
                        "flow-detection",
                        "violation-report-rate" arg,
                        "flow-report-rate" arg,
                        "flow-detection-mode" (
                          ("automatic" | "on" | "off")
                        ),
                        "flow-level-control" (
                          ("drop" | "keep" | "police")
                        )
                    )
                ),
                "protocols" (
                    c(
                        "ipv4-unclassified" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ipv6-unclassified" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "resolve" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "other" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "ucast-v4" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "mcast-v4" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "ucast-v6" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "mcast-v6" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "filter-action" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "other" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "filter-v4" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "filter-v6" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "dynamic-vlan" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ppp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "lcp" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "authentication" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "ipcp" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "ipv6cp" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "mplscp" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "isis" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "echo-req" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "echo-rep" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "mlppp-lcp" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pppoe" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "padi" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "pado" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "padr" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "pads" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "padt" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "padm" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "padn" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "dhcpv4" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "discover" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "offer" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "request" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "decline" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "ack" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "nak" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "release" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "inform" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "renew" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "force-renew" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "lease-query" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "lease-unassigned" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "lease-unknown" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "lease-active" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "bootp" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "no-message-type" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "bad-packets" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                )
                            )
                        ),
                        "dhcpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "solicit" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "advertise" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "request" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "confirm" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "renew" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "rebind" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "reply" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "release" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "decline" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "reconfigure" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "information-request" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "relay-forward" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "relay-reply" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "leasequery" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "leasequery-reply" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "leasequery-done" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "leasequery-data" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                )
                            )
                        ),
                        "virtual-chassis" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "control-high" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "control-low" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "vc-packets" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "vc-ttl-errors" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "icmp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "igmp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ospf" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "rsvp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pim" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "rip" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ptp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "bfd" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "multihop-bfd" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                )
                            )
                        ),
                        "lmp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ldp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "ldp-hello" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                )
                            )
                        ),
                        "msdp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "bgp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "vrrp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "telnet" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ftp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ssh" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "snmp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ancp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "igmpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "mld" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                )
                            )
                        ),
                        "egpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "rsvpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "igmpv4v6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ripv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "bfdv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "lmpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ldpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "msdpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "bgpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "vrrpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "telnetv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ftpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "sshv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "snmpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ancpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ospfv3v6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "lacp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "stp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "esmc" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "oam-lfm" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "eoam" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "oam-cfm" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                )
                            )
                        ),
                        "lldp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "mvrp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pmvrp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "arp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "arp-snoop" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                )
                            )
                        ),
                        "pvstp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "isis" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pos" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "mlp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "lookup" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "add" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "delete" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "macpin-exception" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "jfm" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "atm" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pfe-alive" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ttl" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ip-options" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "router-alert" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "non-v4v6" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "redirect" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "multicast-copy" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "exceptions" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "mtu-exceeded" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "mcast-rpf-err" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "mac-host" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "tunnel-fragment" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "mcast-snoop" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "igmp" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "pim" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "mld" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "services" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "packet" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "bsdt" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "demux-autosense" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "reject" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "firewall-host" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "tcp-flags" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "initial" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "established" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "dtcp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "radius" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "server" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "accounting" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "authorization" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ntp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "tacacs" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "dns" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "diameter" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ip-fragments" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "first-fragment" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "trail-fragment" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "l2tp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "gre" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "hbc" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "punt" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pimv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "icmpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ndpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "router-solicitation" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "router-advertisement" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "neighbor-solicitation" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "neighbor-advertisement" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "redirect" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "invalid-hop-limit" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "sample" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "syslog" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "host" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "pfe" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "tap" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "sflow" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "re-services" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "captive-portal" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "re-services-v6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "captive-portal" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "fab-probe" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "unclassified" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "other" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "resolve-v4" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "resolve-v6" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "control-v4" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "control-v6" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "host-route-v4" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "host-route-v6" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "filter-v4" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "filter-v6" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "control-layer2" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "fw-host" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                ),
                                "mcast-copy" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        )
                                    )
                                )
                            )
                        ),
                        "rejectv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "l2pt" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "tunnel-ka" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "inline-ka" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "inline-svcs" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "frame-relay" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg
                                            )
                                        )
                                    )
                                ),
                                "frf15" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "frf16" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "amtv4" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "amtv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "syslog" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pim-ctrl" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ospf-hello" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pim-data" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "fip-snooping" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "unknown-l2mc" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "nonucast-switch" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ipmcast-miss" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "urpf-fail" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "l3nhop" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "martian-address" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "l3mc-sgv-hit-icl" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "l3dest-miss" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ipmc-reserved" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "garp-reply" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "l3mtu-fail" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "sample-dest" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "sample-source" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "vcipc-udp" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "vxlan" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "bfd" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "dhcpv4v6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "localnh" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "proto-802-1x" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "all-fiber-channel-enode" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "tcc" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "unclassified" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "ethernet-tcc" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                ),
                                "iso-tcc" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "bypass-aggregate",
                                        "priority" (
                                          ("high" | "medium" | "low")
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "pkt-inject" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        ),
                        "ptpv6" (
                            c(
                                "aggregate" (
                                    c(
                                        "bandwidth" arg,
                                        "burst" arg,
                                        "recover-time" arg,
                                        "disable-routing-engine",
                                        "disable-fpc",
                                        "disable-logging",
                                        "violation" (
                                            c(
                                                "disable-logging"
                                            )
                                        ),
                                        "flow-detection-mode" (
                                          ("automatic" | "on" | "off")
                                        ),
                                        "flow-level-bandwidth" (
                                            c(
                                                "subscriber" arg,
                                                "logical-interface" arg,
                                                "physical-interface" arg
                                            )
                                        ),
                                        "flow-level-detection" (
                                            c(
                                                "subscriber" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "logical-interface" (
                                                  ("automatic" | "on" | "off")
                                                ),
                                                "physical-interface" (
                                                  ("automatic" | "on" | "off")
                                                )
                                            )
                                        ),
                                        "flow-level-control" (
                                            c(
                                                "subscriber" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "logical-interface" (
                                                  ("drop" | "keep" | "police")
                                                ),
                                                "physical-interface" (
                                                  ("drop" | "keep" | "police")
                                                )
                                            )
                                        ),
                                        "no-flow-logging",
                                        "timeout-active-flows",
                                        "flow-detect-time" arg,
                                        "flow-recover-time" arg,
                                        "flow-timeout-time" arg,
                                        "fpc" arg (
                                            c(
                                                "disable-fpc",
                                                "bandwidth-scale" arg,
                                                "burst-scale" arg,
                                                "hostbound-queue" arg
                                            )
                                        ),
                                        "hostbound-queue" arg
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ),
        "packet-triggered-subscribers-partition" (
            c(
                  arg,
                "partition" arg (
                    c(
                        "service-set" arg,
                        "service-set-prefix" arg
                    )
                ),
                "exclude-service-set" arg
            )
        ),
        "ntp" (
            c(
                "boot-server" (
                  ipaddr
                ),
                "authentication-key" arg (
                    c(
                        "type" (
                          ("md5" | "des")
                        ),
                        "value" (
                          unreadable
                        )
                    )
                ).as(:oneline),
                "peer" arg (
                    c(
                        "key" arg,
                        "version" arg,
                        "prefer"
                    )
                ).as(:oneline),
                "server" arg (
                    c(
                        "key" arg,
                        "version" arg,
                        "prefer"
                    )
                ).as(:oneline),
                "broadcast" arg (
                    c(
                        "routing-instance-name" arg,
                        "key" arg,
                        "version" arg,
                        "ttl" arg
                    )
                ).as(:oneline),
                "broadcast-client",
                "multicast-client" (
                    c(
                          ipaddr
                    )
                ).as(:oneline),
                "trusted-key" arg,
                "source-address" arg (
                    c(
                        "routing-instance" arg
                    )
                ).as(:oneline)
            )
        ),
        "master-password" (
            c(
                "iteration-count" arg,
                "pseudorandom-function" (
                  ("hmac-sha2-256" | "hmac-sha1" | "hmac-sha2-512")
                )
            )
        )
    )
end

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

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

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

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

rule(:bdbrepd_type) do
    c(
        "traceoptions" (
          bdbrepd_traceoptions_type
        )
    )
end

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

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

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

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

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

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

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

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

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

rule(:jet_scripts_file_type) do
  arg.as(:arg) (
    c(
        "checksum" (
            c(
                "md5" arg,
                "sha1" arg,
                "sha-256" arg
            )
        ),
        "arguments" arg,
        "daemonize",
        "username" arg
    )
  )
end

rule(:jptspd_traceoptions_type) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        ),
        "flag" (("configuration" | "general" | "rtsock" | "peer" | "pic" | "radius" | "session" | "all")).as(:oneline)
    )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:li_policy_addr6_simple_object) do
    c(
          ipv6prefix
    )
end

rule(:li_policy_addr_simple_object) do
    c(
          ipv4prefix
    )
end

rule(:license_object) do
    c(
        "autoupdate" (
            c(
                "url" arg (
                    c(
                        "password" arg
                    )
                ).as(:oneline)
            )
        ),
        "renew" (
            c(
                "before-expiration" arg,
                "interval" arg
            )
        ).as(:oneline),
        "traceoptions" (
            c(
                "no-remote-trace",
                "file" (
                    c(
                          arg,
                        "size" arg,
                        "files" arg,
                        "world-readable",
                        "no-world-readable",
                        "match" (
                          regular_expression
                        )
                    )
                ).as(:oneline),
                "flag" (("all" | "events" | "config")).as(:oneline)
            )
        ),
        "keys" (
            c(
                "key" arg
            )
        )
    )
end

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

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

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

rule(:login_user_object) do
  arg.as(:arg) (
    c(
        "full-name" arg,
        "uid" arg,
        "class" arg,
        "authentication" (
          authentication_object
        )
    )
  )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:match_flags_value) do
    c(
        arg,
        "mask-in-hex" arg
    )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:monitoring_input_type) do
    c(
        "interface" arg
    )
end

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

rule(:cflowd_monitoring_type) do
  arg.as(:arg) (
    c(
        "port" arg,
        "dscp" arg,
        "routing-instance" arg
    )
  )
end

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

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

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

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

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

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

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

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

rule(:mrp_trace_options) do
    c(
        "file" (
          trace_file_type
        ),
        "flag" (("events" | "pdu" | "timers" | "state-machine" | "socket" | "error" | "all")) (
            c(
                "disable"
            )
        ).as(:oneline)
    )
end

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

rule(:multi_chassis_protection_group) do
  arg.as(:arg) (
    c(
        "interface" arg
    )
  )
end

rule(:multi_chassis_protection_group_ifl) do
  arg.as(:arg) (
    c(
        "interface" arg
    )
  )
end

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

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

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

rule(:nameserver_object) do
  arg.as(:arg) (
    c(
        "source-address" (
          ipaddr
        )
    )
  ).as(:oneline)
end

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

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

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

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

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

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

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

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

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

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

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

rule(:ocs_definition) do
    c(
        "partition" arg (
            c(
                "called-station-id" arg,
                "charging-id" arg,
                "destination-realm" arg,
                "destination-host" arg,
                "diameter-instance" arg,
                "draining",
                "draining-response-timeout" arg,
                "force-continue",
                "ggsn-address" (
                  ipaddr
                ),
                "ggsn-mcc-mnc" arg,
                "final-response-timeout" arg,
                "max-outstanding-requests" arg,
                "send-origin-state-id",
                "user-name-include" (
                    c(
                        "delimiter" arg,
                        "domain-name" arg,
                        "interface-name",
                        "base-interface-name",
                        "mac-address",
                        "nas-port-id",
                        "origin-host",
                        "origin-realm",
                        "user-prefix" arg,
                        "user-name"
                    )
                )
            )
        ),
        "global" (
            c(
                "service-context-id" arg
            )
        )
    )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:pgcp_h248_hangterm_object) do
    c(
        "timerx" arg
    )
end

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

rule(:pgcp_h248_notification_behavior_object) do
    c(
        "notification-regulation" (
            c(
                "default" arg
            )
        )
    )
end

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

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

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

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

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

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

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

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

rule(:pgcp_media_service_object) do
  arg.as(:arg) (
    c(
        "nat-pool" arg
    )
  )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:pppoe_options_type) do
    c(
        "underlying-interface" (
          ("$junos-underlying-interface" | arg)
        ),
        "idle-timeout" arg,
        "access-concentrator" arg,
        "service-name" arg,
        "auto-reconnect" arg,
        c(
          "server",
          "client"
        )
    )
end

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

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

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

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

rule(:programmable_rpd_type) do
    c(
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" (("client" | "japi" | "route" | "normal" | "general" | "state" | "policy" | "task" | "timer" | "all")).as(:oneline)
            )
        ),
        "purge-timeout" arg
    )
end

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

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

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

rule(:ptsp_forward_rule_object) do
  arg.as(:arg) (
    c(
        "term" arg (
            c(
                "from" (
                  ptsp_forward_match_object
                ),
                "then" (
                    c(
                        "forwarding-instance" arg,
                        "unit-number" arg
                    )
                )
            )
        )
    )
  )
end

rule(:ptsp_forward_match_object) do
    c(
        "local-address" (
          sfw_addr_object
        ),
        "local-address-range" (
            s(
              "low" arg,
              "high" arg,
              c(
                "except"
              )
            )
        ).as(:oneline),
        "local-prefix-list" arg (
            c(
                "except"
            )
        ).as(:oneline),
        c(
          "applications" arg,
          "nested-applications" arg,
          "application-groups" arg
        )
    )
end

rule(:ptsp_rule_object) do
  arg.as(:arg) (
    c(
        "match-direction" (
          ("input" | "output" | "input-output")
        ),
        "demux" (
          ("source-address" | "destination-address")
        ),
        "count-type" (
          ("rule" | "application")
        ),
        "forward-rule" arg,
        "term" arg (
            c(
                "from" (
                  ptsp_match_object
                ),
                "then" (
                    c(
                        "forwarding-class" arg,
                        "count" (
                          ("none" | "application" | "nested-application" | "application-group" | "application-group-any" | "rule")
                        ),
                        "police" arg,
                        c(
                          "accept",
                          "discard"
                        )
                    )
                )
            )
        )
    )
  )
end

rule(:ptsp_match_object) do
    c(
        "remote-address" (
          sfw_addr_object
        ),
        "remote-address-range" (
            s(
              "low" arg,
              "high" arg,
              c(
                "except"
              )
            )
        ).as(:oneline),
        "remote-prefix-list" arg (
            c(
                "except"
            )
        ).as(:oneline),
        "protocol" arg,
        "local-ports" arg,
        "local-port-range" (
            s(
              "low" arg,
              "high" arg
            )
        ).as(:oneline),
        "remote-ports" arg,
        "remote-port-range" (
            s(
              "low" arg,
              "high" arg
            )
        ).as(:oneline),
        c(
          "application-group-any",
          "applications" arg,
          "nested-applications" arg,
          "application-groups" arg
        )
    )
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:resource_monitor_type) do
    c(
        "resource-category" (("jtree")) (
            c(
                "resource-type" (("free-pages" | "free-dwords" | "contiguous-pages")) (
                    c(
                        "low-watermark" arg,
                        "high-watermark" arg
                    )
                )
            )
        ),
        "traceoptions" (
          resource_monitor_traceoptions_type
        ),
        "no-throttle",
        "no-logging",
        "high-threshold" arg,
        "free-heap-memory-watermark" arg,
        "free-nh-memory-watermark" arg,
        "free-fw-memory-watermark" arg
    )
end

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

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

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

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

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

rule(:rib_static_metric_type) do
    c(
        arg,
        "type" arg
    ).as(:oneline)
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rule(:cflowd_instance_vpls_sampling_type) do
  arg.as(:arg) (
    c(
        "port" arg,
        "dscp" arg,
        "routing-instance" arg,
        "version-ipfix" (
            c(
                "template" (
                    c(
                        arg
                    )
                )
            )
        )
    )
  )
end

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

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

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

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

rule(:satellite_policy_options) do
    c(
        "extended-ports-template" arg (
            c(
                "pic" (
                  satellite_pic_type
                )
            )
        ),
        "port-group-alias" arg (
            c(
                "pic" arg (
                    c(
                        "port" arg
                    )
                )
            )
        ),
        "extended-ports-policy" arg (
            c(
                "term" arg (
                    c(
                        "from" (
                            c(
                                "product-model" arg,
                                "extended-ports-template" arg
                            )
                        )
                    )
                )
            )
        ),
        "candidate-uplink-port-policy" arg (
            c(
                "uplink-port-group" arg,
                "minimum-links" arg,
                "holddown" arg,
                "term" arg (
                    c(
                        "from" (
                            c(
                                "product-model" arg,
                                "uplink-port-group" arg,
                                "minimum-links" arg,
                                "holddown" arg
                            )
                        )
                    )
                )
            )
        ),
        "environment-monitoring-policy" arg (
            c(
                "alarm" (
                    c(
                        "linkdown" (
                          ("ignore" | "red" | "yellow")
                        )
                    )
                ),
                "term" arg (
                    c(
                        "from" (
                            c(
                                "product-model" arg,
                                "alarm" (
                                    c(
                                        "linkdown" (
                                          ("ignore" | "red" | "yellow")
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ),
        "forwarding-policy" arg (
            c(
                "port-group-extended" (
                  port_extend_type
                ),
                "term" arg (
                    c(
                        "from" (
                            c(
                                "product-model" arg,
                                "port-group-extended" (
                                  port_extend_type
                                )
                            )
                        )
                    )
                )
            )
        )
    )
end

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

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

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

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

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

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

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

rule(:op_scripts_file_type) do
  arg.as(:arg) (
    c(
        "command" arg,
        "dampen" (
            c(
                "dampen-options" (
                    c(
                        "cpu-factor" arg,
                        "line-interval" arg,
                        "time-interval" arg
                    )
                )
            )
        ),
        "description" arg,
        "source" arg,
        "allow-commands" (
          regular_expression
        ),
        "refresh",
        "refresh-from" arg,
        "arguments" arg (
            c(
                "description" arg
            )
        ),
        "checksum" (
            c(
                "md5" arg,
                "sha1" arg,
                "sha-256" arg
            )
        )
    )
  )
end

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

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

rule(:sec_object) do
    c(
        "security-name" arg,
        "context" arg
    )
end

rule(:securid_server_object) do
  arg.as(:arg) (
    c(
        "configuration-file" arg
    )
  )
end

rule(:security_authentication_key_chains) do
    c(
        "key-chain" arg (
            c(
                "description" arg,
                "tolerance" arg,
                "key" arg (
                    c(
                        "secret" arg,
                        "start-time" (
                          time
                        ),
                        "algorithm" (
                          ("md5" | "hmac-sha-1")
                        ),
                        "options" (
                          ("basic" | "isis-enhanced")
                        )
                    )
                )
            )
        )
    )
end

rule(:security_dhcpv6_options_type) do
    c(
        "option-37" (
            c(
                "prefix" (
                    c(
                        "host-name",
                        "logical-system-name",
                        "routing-instance-name",
                        "vlan-name",
                        "vlan-id"
                    )
                ),
                "use-interface-mac",
                "use-interface-index" (
                  ("logical" | "device")
                ),
                "use-interface-name" (
                  ("logical" | "device")
                ),
                "use-interface-description" (
                  ("logical" | "device")
                ),
                "use-string" arg
            )
        ),
        "option-18" (
            c(
                "prefix" (
                    c(
                        "host-name",
                        "logical-system-name",
                        "routing-instance-name",
                        "vlan-name",
                        "vlan-id"
                    )
                ),
                "use-interface-mac",
                "use-interface-index" (
                  ("logical" | "device")
                ),
                "use-interface-name" (
                  ("logical" | "device")
                ),
                "use-interface-description" (
                  ("logical" | "device")
                ),
                "use-string" arg
            )
        ),
        "option-16" (
            c(
                "use-string" arg
            )
        )
    )
end

rule(:security_group_vpn) do
    c(
        "member" (
          gvpn_member
        )
    )
end

rule(:gvpn_member) do
    c(
        "ike" (
          gvpn_member_ike
        ),
        "ipsec" (
          gvpn_member_ipsec_vpn
        )
    )
end

rule(:gvpn_member_ike) do
    c(
        "traceoptions" (
            c(
                "no-remote-trace",
                "file" (
                    c(
                          arg,
                        "size" arg,
                        "files" arg,
                        "world-readable",
                        "no-world-readable",
                        "match" (
                          regular_expression
                        )
                    )
                ).as(:oneline),
                "level" (
                  ("error" | "warning" | "notice" | "info" | "verbose" | "all")
                ),
                "flag" (("timer" | "routing-socket" | "parse" | "config" | "ike" | "policy-manager" | "general" | "database" | "certificates" | "snmp" | "thread" | "high-availability" | "next-hop-tunnels" | "all")).as(:oneline),
                "gateway-filter" (
                    c(
                        "local-address" (
                          ipv4addr
                        ),
                        "remote-address" (
                          ipv4addr
                        )
                    )
                )
            )
        ),
        "proposal" (
          gvpn_member_ike_proposal
        ),
        "policy" (
          gvpn_member_ike_policy
        ),
        "gateway" arg (
            c(
                "ike-policy" arg,
                "address" (
                  hostname
                ),
                "server-address" (
                  ipv4addr
                ),
                "local-identity" (
                    c(
                        c(
                          "inet" (
                              c(
                                    ipv4addr
                              )
                          ),
                          "hostname" (
                              c(
                                  arg
                              )
                          ),
                          "user-at-hostname" (
                              c(
                                  arg
                              )
                          ),
                          "distinguished-name"
                        )
                    )
                ).as(:oneline),
                "local-address" (
                  ipv4addr
                ),
                "routing-instance" arg
            )
        )
    )
end

rule(:gvpn_member_ike_policy) do
  arg.as(:arg) (
    c(
        "mode" (
          ("main" | "aggressive")
        ),
        "description" arg,
        "proposals" arg,
        "certificate" (
            c(
                "local-certificate" arg,
                "trusted-ca" (
                    c(
                        c(
                          arg,
                          "use-all"
                        )
                    )
                ).as(:oneline),
                "peer-certificate-type" (
                  ("pkcs7" | "x509-signature")
                )
            )
        ),
        "proposal-set" (
          ("basic" | "compatible" | "standard")
        ),
        "pre-shared-key" (
            c(
                c(
                  "ascii-text" arg,
                  "hexadecimal" arg
                )
            )
        ).as(:oneline)
    )
  )
end

rule(:gvpn_member_ike_proposal) do
  arg.as(:arg) (
    c(
        "description" arg,
        "authentication-method" (
          ("pre-shared-keys" | "rsa-signatures" | "dsa-signatures")
        ),
        "dh-group" (
          ("group1" | "group2" | "group5" | "group14")
        ),
        "authentication-algorithm" (
          ("md5" | "sha1" | "sha-256")
        ),
        "encryption-algorithm" (
          ("des-cbc" | "3des-cbc" | "aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc")
        ),
        "lifetime-seconds" arg
    )
  )
end

rule(:gvpn_member_ipsec_vpn) do
    c(
        "vpn" (
          ipsec_gvpn_member_template
        )
    )
end

rule(:ipsec_gvpn_member_template) do
  arg.as(:arg) (
    c(
        "ike-gateway" arg,
        "group-vpn-external-interface" (
          interface_name
        ),
        "group" arg,
        "heartbeat-threshold" arg,
        "match-direction" (
          ("input" | "output")
        ),
        "tunnel-mtu" arg,
        "df-bit" (
          ("clear" | "set" | "copy")
        ),
        "fail-open" (
          ipsec_gvpn_fail_open_rule_object
        )
    )
  )
end

rule(:ipsec_gvpn_fail_open_rule_object) do
    c(
        "rule" (
          ipsec_gvpn_fail_open_rule_address_object
        )
    )
end

rule(:ipsec_gvpn_fail_open_rule_address_object) do
  arg.as(:arg) (
    c(
        "source-address" (
          ipsec_gvpn_addr_object
        ),
        "destination-address" (
          ipsec_gvpn_addr_object
        )
    )
  )
end

rule(:ipsec_gvpn_addr_object) do
    c(
          ipv4prefix_only
    )
end

rule(:security_ike) do
    c(
        "traceoptions" (
          security_traceoptions
        ),
        "respond-bad-spi" (
            c(
                  arg
            )
        ).as(:oneline),
        "proposal" (
          ike_proposal
        ),
        "policy" (
          ike_policy
        ),
        "gateway" arg (
            c(
                "ike-policy" arg,
                c(
                  "address" (
                    (arg)
                  ),
                  "dynamic" (
                      c(
                          c(
                            "distinguished-name" (
                                c(
                                    "container" arg,
                                    "wildcard" arg
                                )
                            ),
                            "hostname" arg,
                            "inet" (
                              ipv4addr
                            ),
                            "inet6" (
                              ipv6addr
                            ),
                            "user-at-hostname" arg
                          ),
                          "connections-limit" arg,
                          "ike-user-type" (
                            ("group-ike-id" | "shared-ike-id")
                          )
                      )
                  )
                ),
                "dead-peer-detection" (
                    c(
                        "always-send",
                        "interval" arg,
                        "threshold" arg
                    )
                ),
                "no-nat-traversal",
                "nat-keepalive" arg,
                "local-identity" (
                    c(
                        c(
                          "inet" (
                              c(
                                    ipv4addr
                              )
                          ),
                          "inet6" (
                              c(
                                    ipv6addr
                              )
                          ),
                          "hostname" (
                              c(
                                  arg
                              )
                          ),
                          "user-at-hostname" (
                              c(
                                  arg
                              )
                          ),
                          "distinguished-name"
                        )
                    )
                ).as(:oneline),
                "remote-identity" (
                    c(
                        c(
                          "inet" (
                              c(
                                    ipv4addr
                              )
                          ),
                          "inet6" (
                              c(
                                    ipv6addr
                              )
                          ),
                          "hostname" (
                              c(
                                  arg
                              )
                          ),
                          "user-at-hostname" (
                              c(
                                  arg
                              )
                          ),
                          "distinguished-name" (
                              c(
                                  "container" arg,
                                  "wildcard" arg
                              )
                          )
                        )
                    )
                ).as(:oneline),
                "external-interface" (
                  interface_unit
                ),
                "xauth" (
                    c(
                        "access-profile" arg
                    )
                ).as(:oneline),
                "general-ikeid",
                "version" (
                  ("v1-only" | "v2-only")
                )
            )
        )
    )
end

rule(:ike_policy) do
  arg.as(:arg) (
    c(
        "mode" (
          ("main" | "aggressive")
        ),
        "description" arg,
        "proposals" arg,
        "local-certificate" arg,
        "local-key-pair" arg,
        "encoding" (
          ("binary" | "pem")
        ),
        "identity" arg,
        "pre-shared-key" (
            c(
                c(
                  "ascii-text" arg,
                  "hexadecimal" arg
                )
            )
        ).as(:oneline)
    )
  )
end

rule(:ike_proposal) do
  arg.as(:arg) (
    c(
        "description" arg,
        "authentication-method" (
          ("pre-shared-keys" | "rsa-signatures" | "dsa-signatures")
        ),
        "dh-group" (
          ("group1" | "group2" | "group5" | "group14" | "group19" | "group20")
        ),
        "authentication-algorithm" (
          ("md5" | "sha1" | "sha-256" | "sha-384")
        ),
        "encryption-algorithm" (
          ("des-cbc" | "3des-cbc" | "aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc")
        ),
        "lifetime-seconds" arg
    )
  )
end

rule(:security_ipsec) do
    c(
        "proposal" (
          ipsec_proposal
        ),
        "policy" (
          ipsec_policy
        ),
        "security-association" (
          ipsec_sa
        ),
        "internal" (
            c(
                "security-association" (
                  ipsec_internal_sa
                )
            )
        ),
        "trusted-channel" (
            c(
                "security-association" (
                  ipsec_trusted_channel_sa
                ),
                "port-exclusion-list" arg
            )
        )
    )
end

rule(:ipsec_internal_sa) do
    c(
        "description" arg,
        "manual" (
            c(
                "direction" (("inbound" | "outbound" | "bidirectional")) (
                    c(
                        "protocol" (
                          ("ah" | "esp" | "bundle")
                        ),
                        "spi" arg,
                        "auxiliary-spi" arg,
                        "authentication" (
                            c(
                                "algorithm" (
                                  ("hmac-md5-96" | "hmac-sha1-96" | "hmac-sha2-256" | "hmac-sha-256-128")
                                ),
                                "key" (
                                    c(
                                        c(
                                          "ascii-text" arg,
                                          "hexadecimal" arg
                                        )
                                    )
                                ).as(:oneline)
                            )
                        ),
                        "encryption" (
                            c(
                                "algorithm" (
                                  ("des-cbc" | "3des-cbc" | "aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc")
                                ),
                                "key" (
                                    c(
                                        c(
                                          "ascii-text" arg,
                                          "hexadecimal" arg
                                        )
                                    )
                                ).as(:oneline)
                            )
                        )
                    )
                )
            )
        )
    )
end

rule(:ipsec_policy) do
  arg.as(:arg) (
    c(
        "description" arg,
        "perfect-forward-secrecy" (
            c(
                "keys" (
                  ("group1" | "group2" | "group5" | "group14" | "group19" | "group20")
                )
            )
        ),
        "proposals" arg,
        "proposal-set" (
          ("basic" | "compatible" | "standard")
        )
    )
  )
end

rule(:ipsec_proposal) do
  arg.as(:arg) (
    c(
        "description" arg,
        "protocol" (
          ("ah" | "esp" | "bundle")
        ),
        "authentication-algorithm" (
          ("hmac-md5-96" | "hmac-sha1-96" | "hmac-sha-256-128" | "hmac-sha-256-96" | "hmac-sha2-256")
        ),
        "encryption-algorithm" (
          ("des-cbc" | "3des-cbc" | "aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc" | "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm")
        ),
        "lifetime-seconds" arg
    )
  )
end

rule(:ipsec_sa) do
  arg.as(:arg) (
    c(
        "description" arg,
        "mode" (
          ("transport" | "tunnel")
        ),
        c(
          "manual" (
              c(
                  "direction" (("inbound" | "outbound" | "bidirectional")) (
                      c(
                          "protocol" (
                            ("ah" | "esp" | "bundle")
                          ),
                          "spi" arg,
                          "auxiliary-spi" arg,
                          "authentication" (
                              c(
                                  "algorithm" (
                                    ("hmac-md5-96" | "hmac-sha1-96" | "hmac-sha2-256" | "hmac-sha-256-128")
                                  ),
                                  "key" (
                                      c(
                                          c(
                                            "ascii-text" arg,
                                            "hexadecimal" arg
                                          )
                                      )
                                  ).as(:oneline)
                              )
                          ),
                          "encryption" (
                              c(
                                  "algorithm" (
                                    ("des-cbc" | "3des-cbc" | "aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc")
                                  ),
                                  "key" (
                                      c(
                                          c(
                                            "ascii-text" arg,
                                            "hexadecimal" arg
                                          )
                                      )
                                  ).as(:oneline)
                              )
                          )
                      )
                  )
              )
          ),
          "dynamic" (
              c(
                  "replay-window-size" (
                    ("32" | "64")
                  ),
                  "ipsec-policy" arg
              )
          )
        )
    )
  )
end

rule(:ipsec_trusted_channel_sa) do
    c(
        "description" arg,
        "manual" (
            c(
                "direction" (("inbound" | "outbound" | "bidirectional")) (
                    c(
                        "protocol" (
                          ("ah" | "esp" | "bundle")
                        ),
                        "spi" arg,
                        "auxiliary-spi" arg,
                        "authentication" (
                            c(
                                "algorithm" (
                                  ("hmac-md5-96" | "hmac-sha1-96" | "hmac-sha2-256" | "hmac-sha-256-128")
                                ),
                                "key" (
                                    c(
                                        c(
                                          "ascii-text" arg,
                                          "hexadecimal" arg
                                        )
                                    )
                                ).as(:oneline)
                            )
                        ),
                        "encryption" (
                            c(
                                "algorithm" (
                                  ("des-cbc" | "3des-cbc" | "aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc")
                                ),
                                "key" (
                                    c(
                                        c(
                                          "ascii-text" arg,
                                          "hexadecimal" arg
                                        )
                                    )
                                ).as(:oneline)
                            )
                        )
                    )
                )
            )
        )
    )
end

rule(:security_macsec) do
    c(
        "traceoptions" (
          macsec_trace_options
        ),
        "connectivity-association" arg (
            c(
                "cipher-suite" (
                  ("gcm-aes-128" | "gcm-aes-256" | "gcm-aes-xpn-128" | "gcm-aes-xpn-256")
                ),
                "security-mode" (
                  ("dynamic" | "static-sak" | "static-cak")
                ),
                "secure-channel" arg (
                    c(
                        "id" (
                            c(
                                "mac-address" (
                                  mac_addr
                                ),
                                "port-id" arg
                            )
                        ),
                        "direction" (
                          ("inbound" | "outbound")
                        ),
                        "encryption",
                        "offset" (
                          ("0" | "30" | "50")
                        ),
                        "include-sci",
                        "security-association" arg (
                            c(
                                "key" arg
                            )
                        )
                    )
                ),
                "mka" (
                    c(
                        "transmit-interval" arg,
                        "key-server-priority" arg,
                        "must-secure"
                    )
                ),
                "replay-protect" (
                    c(
                        "replay-window-size" arg
                    )
                ),
                "no-encryption",
                "offset" (
                  ("0" | "30" | "50")
                ),
                "include-sci",
                "pre-shared-key" (
                    c(
                        "ckn" arg,
                        "cak" arg
                    )
                ),
                "exclude-protocol" (("cdp" | "lldp" | "lacp")).as(:oneline)
            )
        ),
        "interfaces" arg (
            c(
                "connectivity-association" arg,
                "traceoptions" (
                  mka_trace_options
                )
            )
        ),
        "cluster-control-port" arg (
            c(
                "connectivity-association" arg,
                "traceoptions" (
                  mka_trace_options
                )
            )
        ),
        "cluster-data-port" arg (
            c(
                "connectivity-association" arg,
                "traceoptions" (
                  mka_trace_options
                )
            )
        )
    )
end

rule(:macsec_trace_options) do
    c(
        "file" (
          trace_file_type
        ),
        "flag" (("config" | "debug" | "normal" | "all")).as(:oneline)
    )
end

rule(:mka_trace_options) do
    c(
        "file" (
          trace_file_type
        ),
        "flag" (("mka-packets" | "state" | "to-secy" | "keys" | "normal" | "all")).as(:oneline)
    )
end

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

rule(:security_option_82_type) do
    c(
        "circuit-id" (
            c(
                "prefix" (
                    c(
                        "host-name",
                        "logical-system-name",
                        "routing-instance-name"
                    )
                ),
                "use-interface-description" (
                  ("logical" | "device")
                ),
                "use-vlan-id"
            )
        ),
        "remote-id" (
            c(
                "host-name",
                "use-interface-description" (
                  ("logical" | "device")
                ),
                "use-string" arg,
                "mac"
            )
        ),
        "vendor-id" (
            c(
                "use-string" arg
            )
        )
    )
end

rule(:security_pki) do
    c(
        "ca-profile" arg (
            c(
                "ca-identity" arg,
                "source-address" (
                  ipv4addr
                ),
                "routing-instance" arg,
                "enrollment" (
                    c(
                        "url" arg,
                        "retry" arg,
                        "retry-interval" arg
                    )
                ),
                "revocation-check" (
                    c(
                        c(
                          "use-crl",
                          "use-ocsp",
                          "disable"
                        ),
                        "ocsp" (
                            c(
                                "url" arg,
                                "nonce-payload" (
                                  ("enable" | "disable")
                                ),
                                "disable-responder-revocation-check",
                                "accept-unknown-status",
                                "connection-failure" (
                                    c(
                                        c(
                                          "fallback-crl",
                                          "disable"
                                        )
                                    )
                                )
                            )
                        ),
                        "crl" (
                            c(
                                "disable" (
                                    c(
                                        "on-download-failure"
                                    )
                                ).as(:oneline),
                                "url" arg (
                                    c(
                                        "password" (
                                          unreadable
                                        )
                                    )
                                ),
                                "refresh-interval" arg
                            )
                        )
                    )
                ),
                "administrator" (
                    c(
                        "email-address" arg
                    )
                )
            )
        ),
        "auto-re-enrollment" (
            c(
                "cmpv2" (
                    c(
                        "certificate-id" arg (
                            c(
                                "ca-profile-name" arg,
                                "re-enroll-trigger-time-percentage" arg,
                                "re-generate-keypair"
                            )
                        )
                    )
                ),
                "scep" (
                    c(
                        "certificate-id" arg (
                            c(
                                "ca-profile-name" arg,
                                "re-generate-keypair",
                                "re-enroll-trigger-time-percentage" arg,
                                "challenge-password" (
                                  unreadable
                                ),
                                "scep-encryption-algorithm" (
                                    c(
                                        c(
                                          "des",
                                          "des3"
                                        )
                                    )
                                ),
                                "scep-digest-algorithm" (
                                    c(
                                        c(
                                          "md5",
                                          "sha1"
                                        )
                                    )
                                )
                            )
                        )
                    )
                ),
                "certificate-id" arg (
                    c(
                        "ca-profile-name" arg,
                        "re-generate-keypair",
                        "re-enroll-trigger-time-percentage" arg,
                        "challenge-password" (
                          unreadable
                        ),
                        "scep-encryption-algorithm" (
                            c(
                                c(
                                  "des",
                                  "des3"
                                )
                            )
                        ),
                        "scep-digest-algorithm" (
                            c(
                                c(
                                  "md5",
                                  "sha1"
                                )
                            )
                        ),
                        "validity-period" arg
                    )
                )
            )
        ),
        "traceoptions" (
            c(
                "no-remote-trace",
                "file" (
                    c(
                          arg,
                        "size" arg,
                        "files" arg,
                        "world-readable",
                        "no-world-readable",
                        "match" (
                          regular_expression
                        )
                    )
                ).as(:oneline),
                "flag" (("certificate-verification" | "online-crl-check" | "enrollment" | "all")).as(:oneline)
            )
        )
    )
end

rule(:security_traceoptions) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "rate-limit" arg,
        "filter" (
            c(
                "fpc" arg,
                "pic" arg
            )
        ),
        "flag" (("timer" | "routing-socket" | "parse" | "config" | "ike" | "policy-manager" | "general" | "database" | "certificates" | "snmp" | "thread" | "high-availability" | "next-hop-tunnels" | "all" | "ams" | "lic")).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        )
    )
end

rule(:server_bulk_leasequery_type) do
    c(
        "max-connections" arg,
        "timeout" arg,
        "max-empty-replies" arg,
        "restricted-requestor"
    )
end

rule(:server_group_type) do
    c(
            c(
                arg
            )
    )
end

rule(:server_leasequery_type) do
    c(
        "restricted-requestor"
    )
end

rule(:server_v6_option_ascii_hex) do
    c(
        "ascii" arg,
        "hexadecimal" arg
    )
end

rule(:service_device_pool_object) do
  arg.as(:arg) (
    c(
        "interface" arg
    )
  )
end

rule(:service_interface_pool_object) do
  arg.as(:arg) (
    c(
        "interface" arg
    )
  )
end

rule(:service_point_type) do
  arg.as(:arg) (
    c(
        "service-point-type" (
          ("sip")
        ),
        "transport-details" (
            c(
                "port-number" arg,
                "ip-address" (
                  ipaddr
                ),
                "tcp",
                "udp",
                "fqdn" arg
            )
        ).as(:oneline),
        "service-interface" (
          interface_unit
        ),
        "service-policies" (
          service_policies_type
        ),
        "default-media-realm" arg
    )
  )
end

rule(:service_policies_type) do
    c(
        "new-transaction-input-policies" arg,
        "new-transaction-output-policies" arg,
        "new-registration-input-policies" arg,
        "new-call-usage-input-policies" arg,
        "new-call-usage-output-policies" arg
    )
end

rule(:service_set_ipsec_vpn_options_object) do
    c(
        "trusted-ca" arg,
        "local-gateway" (
            c(
                  ipaddr,
                "routing-instance" arg,
                "interface" (
                  interface_unit
                ),
                "gw-interface" (
                  interface_unit
                )
            )
        ).as(:oneline),
        "ike-access-profile" arg,
        "passive-mode-tunneling",
        "clear-dont-fragment-bit",
        "copy-dont-fragment-bit",
        "set-dont-fragment-bit",
        "tunnel-mtu" arg,
        "no-anti-replay",
        "anti-replay-window-size" arg,
        "udp-encapsulate" (
            c(
                "dest-port" arg
            )
        ).as(:oneline)
    )
end

rule(:service_set_syslog_object) do
    c(
        "host" arg (
            c(
                    c(
                        c(
                          "any",
                          "emergency",
                          "alert",
                          "critical",
                          "error",
                          "warning",
                          "notice",
                          "info",
                          "none"
                        )
                    ).as(:oneline),
                "facility-override" (
                  ("authorization" | "daemon" | "ftp" | "kernel" | "user" | "local0" | "local1" | "local2" | "local3" | "local4" | "local5" | "local6" | "local7")
                ),
                "log-prefix" arg,
                "port" arg,
                "class" (
                    c(
                        "session-logs" (
                            c(
                                "open",
                                "close"
                            )
                        ),
                        "packet-logs",
                        "stateful-firewall-logs",
                        "alg-logs",
                        "nat-logs",
                        "ids-logs",
                        "pcp-logs" (
                            c(
                                "map",
                                "debug"
                            )
                        ).as(:oneline),
                        "ha-logs" (
                            c(
                                "open-synchronized",
                                "close-synchronized"
                            )
                        )
                    )
                ),
                "source-address" (
                  ipv4addr
                )
            )
        ),
        "message-rate-limit" arg
    )
end

rule(:services_ike) do
    c(
        "proposal" (
          ike_proposal
        ),
        "policy" (
          svc_ike_policy
        )
    )
end

rule(:services_ipsec) do
    c(
        "proposal" (
          ipsec_proposal
        ),
        "policy" (
          ipsec_policy
        )
    )
end

rule(:services_pcef) do
    c(
        "traceoptions" (
          pcef_traceoptions
        ),
        "event-trigger-profiles" (
            c(
                  evt_trigger_profile
            )
        ),
        "flow-descriptions" (
            c(
                  pcc_flow
            )
        ),
        "pcc-action-profiles" (
            c(
                  pcc_action_profile
            )
        ),
        "pcc-rules" (
            c(
                  pcc_rule
            )
        ),
        "pcc-rulebases" (
            c(
                  pcc_rulebase
            )
        ),
        "profile" (
            c(
                  pcef_profiles
            )
        )
    )
end

rule(:evt_trigger_profile) do
  arg.as(:arg) (
    c(
        "rat-change",
        "sgsn-change",
        "plmn-change",
        "ip-can-change",
        "tft-change",
        "rai-change",
        "user-location-change",
        "ue-timezone-change"
    )
  )
end

rule(:pcc_action_profile) do
  arg.as(:arg) (
    c(
        "logging-rule" arg,
        "maximum-bit-rate" (
            c(
                "uplink" arg,
                "downlink" arg
            )
        ).as(:oneline),
        "burst-size" (
            c(
                "uplink" arg,
                "downlink" arg
            )
        ),
        "gate-status" (
          ("uplink" | "downlink" | "uplink-downlink" | "disable-both")
        ),
        "charging" (
            c(
                "rating-group" arg,
                "service-identifier" arg,
                "charging-method" (
                  ("online" | "offline" | "both" | "none")
                ),
                "measurement-method" (
                  ("none" | "volume" | "time" | "volume-time" | "event")
                ),
                "application-function-record-info" (
                    c(
                        "af-charging-identifier" arg
                    )
                ),
                "service-id-level-reporting"
            )
        ),
        "redirect" (
            c(
                "url" arg
            )
        ),
        "forwarding-class" (
            c(
                arg
            )
        ),
        "steering" (
            c(
                "routing-instance" (
                    c(
                        "uplink" arg,
                        "downlink" arg
                    )
                ).as(:oneline),
                "path" (
                    c(
                        c(
                          "ipv4-address" (
                            ipv4prefix
                          ),
                          "ipv6-address" (
                            ipv6prefix
                          )
                        )
                    )
                ).as(:oneline),
                "keep-existing-steering"
            )
        ),
        "hcm-profile" (
            c(
                arg
            )
        ),
        "monitoring-key" arg
    )
  )
end

rule(:pcc_flow) do
  arg.as(:arg) (
    c(
        "direction" (
          ("downlink" | "uplink" | "both")
        ),
        "protocol" arg,
        "local-ports" arg,
        "local-port-range" (
            s(
              "low" arg,
              "high" arg
            )
        ).as(:oneline),
        "remote-ports" arg,
        "remote-port-range" (
            s(
              "low" arg,
              "high" arg
            )
        ).as(:oneline),
        "remote-address" (
            c(
                c(
                  "ipv4-address" (
                    ipv4prefix
                  ),
                  "ipv6-address" (
                    ipv6prefix
                  )
                )
            )
        ).as(:oneline)
    )
  )
end

rule(:pcc_rule) do
  arg.as(:arg) (
    c(
        "from" (
            c(
                "flows" arg,
                "applications" arg,
                "nested-applications" arg,
                "application-groups" arg
            )
        ),
        "then" (
            c(
                "pcc-action-profile" arg
            )
        )
    )
  )
end

rule(:pcc_rulebase) do
  arg.as(:arg) (
    c(
        "pcc-rule" arg (
            c(
                "precedence" arg
            )
        ).as(:oneline)
    )
  )
end

rule(:pcef_profiles) do
  arg.as(:arg) (
    c(
        "control-byte-rating-group" arg,
        "unresolved-flow-action" (
          ("forward" | "drop")
        ),
        "maximum-per-pdn-service-flows" (
            c(
                arg
            )
        ).as(:oneline),
        "dynamic-policy-control" (
            c(
                "pcc-rules" (
                    c(
                          profile_rule_assoc
                    )
                ),
                "pcc-rulebases" arg,
                "diameter-profile" arg,
                "event-trigger-profile" arg,
                "session-failover-not-supported",
                "release" (
                  ("r8" | "r9")
                )
            )
        ),
        "static-policy-control" (
            c(
                "pcc-rules" (
                    c(
                          profile_static_rule_association
                    )
                ),
                "pcc-rulebases" arg (
                    c(
                        "time-of-day-profile" arg
                    )
                ),
                "activate-dedicated-bearers" arg
            )
        ),
        "aaa-policy-control" (
            c(
                "profile" arg,
                "user-password" arg,
                "pcc-rulebases" arg
            )
        )
    )
  )
end

rule(:pcef_traceoptions) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable"
            )
        ).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        ),
        "flag" (("init" | "config" | "general" | "high-availability" | "debug" | "fsm" | "tftmgr" | "all")).as(:oneline)
    )
end

rule(:profile_rule_assoc) do
  arg.as(:arg) (
    c(
        "precedence" arg
    )
  ).as(:oneline)
end

rule(:profile_static_rule_association) do
  arg.as(:arg) (
    c(
        "precedence" arg,
        "time-of-day-profile" arg,
        "pcc-action-profile" (
            c(
                  arg
            )
        ).as(:oneline)
    )
  ).as(:oneline)
end

rule(:sfw_addr_object) do
  ("any-unicast" | "any-ipv4" | "any-ipv6" | arg).as(:arg) (
    c(
        "except"
    )
  ).as(:oneline)
end

rule(:sfw_match_object) do
    c(
        "source-address" (
          sfw_addr_object
        ),
        "destination-address" (
          sfw_addr_object
        ),
        "destination-port" (
            c(
                c(
                  "range" (
                      c(
                          "low" arg,
                          "high" arg
                      )
                  ).as(:oneline)
                )
            )
        ),
        "source-address-range" (
            s(
              "low" arg,
              "high" arg,
              c(
                "except"
              )
            )
        ).as(:oneline),
        "source-prefix-list" arg (
            c(
                "except"
            )
        ).as(:oneline),
        "destination-address-range" (
            s(
              "low" arg,
              "high" arg,
              c(
                "except"
              )
            )
        ).as(:oneline),
        "destination-prefix-list" arg (
            c(
                "except"
            )
        ).as(:oneline),
        "applications" arg,
        "application-sets" arg
    )
end

rule(:sfw_rule_object) do
  arg.as(:arg) (
    c(
        "match-direction" (
          ("input" | "output" | "input-output")
        ),
        "term" arg (
            c(
                "from" (
                  sfw_match_object
                ),
                "then" (
                    c(
                        c(
                          "accept",
                          "discard",
                          "reject"
                        ),
                        "allow-ip-options" (
                              ("any" | "strict-source-route" | "loose-source-route" | "route-record" | "timestamp" | "router-alert" | "security" | "stream-id" | arg)
                        ),
                        "syslog",
                        "skip-ids"
                    )
                )
            )
        )
    )
  )
end

rule(:sgw_config_gtp) do
    c(
        "peer-history" arg,
        "interface" (
            c(
                  interface_name,
                "v4-address" (
                  ipv4addr
                )
            )
        ).as(:oneline),
        "echo-interval" arg,
        "path-management" (
          ("enable" | "disable")
        ),
        "echo-n3-requests" arg,
        "echo-t3-response" arg,
        "path-failure" (
          ("enable" | "disable")
        ),
        "number-of-msgs-for-response-time" arg,
        "control" (
            c(
                "interface" (
                    c(
                          interface_name,
                        "v4-address" (
                          ipv4addr
                        )
                    )
                ).as(:oneline),
                "echo-interval" arg,
                "path-management" (
                  ("enable" | "disable")
                ),
                "echo-n3-requests" arg,
                "echo-t3-response" arg,
                "path-failure" (
                  ("enable" | "disable")
                ),
                "number-of-msgs-for-response-time" arg,
                "forwarding-class" arg,
                "n3-requests" arg,
                "t3-response" arg,
                "dscp-code-point" arg,
                "ttl-value" arg,
                "ddn-delay-sync" (
                  ("enable" | "disable")
                ),
                "no-response-cache",
                "response-cache-timeout" arg,
                "no-piggyback-support"
            )
        ),
        "data" (
            c(
                "interface" (
                    c(
                          interface_name,
                        "v4-address" (
                          ipv4addr
                        )
                    )
                ).as(:oneline),
                "echo-interval" arg,
                "path-management" (
                  ("enable" | "disable")
                ),
                "echo-n3-requests" arg,
                "echo-t3-response" arg,
                "path-failure" (
                  ("enable" | "disable")
                ),
                "num-gtpu-end-markers" arg,
                "indirect-tunnel" (
                  ("enable" | "disable")
                ),
                "error-indication-interval" arg
            )
        ),
        "s1u" (
            c(
                "interface" (
                    c(
                          interface_name,
                        "v4-address" (
                          ipv4addr
                        )
                    )
                ).as(:oneline),
                "echo-interval" arg,
                "path-management" (
                  ("enable" | "disable")
                ),
                "echo-n3-requests" arg,
                "echo-t3-response" arg,
                "path-failure" (
                  ("enable" | "disable")
                )
            )
        ),
        "s11" (
            c(
                "interface" (
                    c(
                          interface_name,
                        "v4-address" (
                          ipv4addr
                        )
                    )
                ).as(:oneline),
                "echo-interval" arg,
                "path-management" (
                  ("enable" | "disable")
                ),
                "echo-n3-requests" arg,
                "echo-t3-response" arg,
                "path-failure" (
                  ("enable" | "disable")
                ),
                "number-of-msgs-for-response-time" arg,
                "forwarding-class" arg,
                "n3-requests" arg,
                "t3-response" arg,
                "dscp-code-point" arg,
                "ttl-value" arg
            )
        ),
        "s12" (
            c(
                "interface" (
                    c(
                          interface_name,
                        "v4-address" (
                          ipv4addr
                        )
                    )
                ).as(:oneline),
                "echo-interval" arg,
                "path-management" (
                  ("enable" | "disable")
                ),
                "echo-n3-requests" arg,
                "echo-t3-response" arg,
                "path-failure" (
                  ("enable" | "disable")
                )
            )
        ),
        "s4" (
            c(
                "interface" (
                    c(
                          interface_name,
                        "v4-address" (
                          ipv4addr
                        )
                    )
                ).as(:oneline),
                "echo-interval" arg,
                "path-management" (
                  ("enable" | "disable")
                ),
                "echo-n3-requests" arg,
                "echo-t3-response" arg,
                "path-failure" (
                  ("enable" | "disable")
                ),
                "number-of-msgs-for-response-time" arg,
                "control" (
                    c(
                        "interface" (
                            c(
                                  interface_name,
                                "v4-address" (
                                  ipv4addr
                                )
                            )
                        ).as(:oneline),
                        "echo-interval" arg,
                        "path-management" (
                          ("enable" | "disable")
                        ),
                        "echo-n3-requests" arg,
                        "echo-t3-response" arg,
                        "path-failure" (
                          ("enable" | "disable")
                        ),
                        "number-of-msgs-for-response-time" arg,
                        "forwarding-class" arg,
                        "n3-requests" arg,
                        "t3-response" arg,
                        "dscp-code-point" arg,
                        "ttl-value" arg
                    )
                ),
                "data" (
                    c(
                        "interface" (
                            c(
                                  interface_name,
                                "v4-address" (
                                  ipv4addr
                                )
                            )
                        ).as(:oneline),
                        "echo-interval" arg,
                        "path-management" (
                          ("enable" | "disable")
                        ),
                        "echo-n3-requests" arg,
                        "echo-t3-response" arg,
                        "path-failure" (
                          ("enable" | "disable")
                        )
                    )
                )
            )
        ),
        "s5" (
            c(
                "interface" (
                    c(
                          interface_name,
                        "v4-address" (
                          ipv4addr
                        )
                    )
                ).as(:oneline),
                "echo-interval" arg,
                "path-management" (
                  ("enable" | "disable")
                ),
                "echo-n3-requests" arg,
                "echo-t3-response" arg,
                "path-failure" (
                  ("enable" | "disable")
                ),
                "number-of-msgs-for-response-time" arg,
                "control" (
                    c(
                        "interface" (
                            c(
                                  interface_name,
                                "v4-address" (
                                  ipv4addr
                                )
                            )
                        ).as(:oneline),
                        "echo-interval" arg,
                        "path-management" (
                          ("enable" | "disable")
                        ),
                        "echo-n3-requests" arg,
                        "echo-t3-response" arg,
                        "path-failure" (
                          ("enable" | "disable")
                        ),
                        "number-of-msgs-for-response-time" arg,
                        "forwarding-class" arg,
                        "n3-requests" arg,
                        "t3-response" arg,
                        "dscp-code-point" arg,
                        "ttl-value" arg
                    )
                ),
                "data" (
                    c(
                        "interface" (
                            c(
                                  interface_name,
                                "v4-address" (
                                  ipv4addr
                                )
                            )
                        ).as(:oneline),
                        "echo-interval" arg,
                        "path-management" (
                          ("enable" | "disable")
                        ),
                        "echo-n3-requests" arg,
                        "echo-t3-response" arg,
                        "path-failure" (
                          ("enable" | "disable")
                        )
                    )
                )
            )
        ),
        "s8" (
            c(
                "interface" (
                    c(
                          interface_name,
                        "v4-address" (
                          ipv4addr
                        )
                    )
                ).as(:oneline),
                "echo-interval" arg,
                "path-management" (
                  ("enable" | "disable")
                ),
                "echo-n3-requests" arg,
                "echo-t3-response" arg,
                "path-failure" (
                  ("enable" | "disable")
                ),
                "number-of-msgs-for-response-time" arg,
                "control" (
                    c(
                        "interface" (
                            c(
                                  interface_name,
                                "v4-address" (
                                  ipv4addr
                                )
                            )
                        ).as(:oneline),
                        "echo-interval" arg,
                        "path-management" (
                          ("enable" | "disable")
                        ),
                        "echo-n3-requests" arg,
                        "echo-t3-response" arg,
                        "path-failure" (
                          ("enable" | "disable")
                        ),
                        "number-of-msgs-for-response-time" arg,
                        "forwarding-class" arg,
                        "n3-requests" arg,
                        "t3-response" arg,
                        "dscp-code-point" arg,
                        "ttl-value" arg
                    )
                ),
                "data" (
                    c(
                        "interface" (
                            c(
                                  interface_name,
                                "v4-address" (
                                  ipv4addr
                                )
                            )
                        ).as(:oneline),
                        "echo-interval" arg,
                        "path-management" (
                          ("enable" | "disable")
                        ),
                        "echo-n3-requests" arg,
                        "echo-t3-response" arg,
                        "path-failure" (
                          ("enable" | "disable")
                        )
                    )
                )
            )
        ),
        "traceoptions" (
          gtp_traceoptions
        )
    )
end

rule(:sgw_idle_mode_buffering) do
    c(
        "disable",
        "expire-timer" arg
    )
end

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

rule(:sip_timers_type) do
    c(
        "inactive-call" arg,
        "timer-c" arg
    )
end

rule(:sm_ippool_pool) do
  arg.as(:arg) (
    c(
        "service-mode" (
          ("maintenance")
        ),
        "family" (
            c(
                c(
                  "inet" (
                      c(
                          "network" arg (
                              c(
                                  "external-assigned",
                                  "allocation-prefix-length" arg,
                                  "range" arg (
                                      c(
                                          "low" (
                                            ipv4addr
                                          ),
                                          "high" (
                                            ipv4addr
                                          ),
                                          "external-assigned"
                                      )
                                  )
                              )
                          )
                      )
                  ),
                  "inet6" (
                      c(
                          "network" arg (
                              c(
                                  "external-assigned",
                                  "allocation-prefix-length" arg,
                                  "range" arg (
                                      c(
                                          "low" (
                                            ipv6prefix_only
                                          ),
                                          "high" (
                                            ipv6prefix_only
                                          ),
                                          "external-assigned"
                                      )
                                  )
                              )
                          )
                      )
                  )
                )
            )
        ),
        "ageing-window" arg,
        "pool-prefetch-threshold" arg,
        "pool-snmp-trap-threshold" arg,
        "default-pool"
    )
  )
end

rule(:smid_type) do
    c(
        "traceoptions" (
          smid_traceoptions_type
        ),
        "maintain-subscriber" (
          smid_maintain_subscriber_type
        ),
        "gres-route-flush-delay",
        "enforce-strict-scale-limit-license",
        "overrides" (
            c(
                "no-unsolicited-ra",
                "shmlog" (
                    c(
                        "disable",
                        "filtering" (
                            c(
                                "enable"
                            )
                        ),
                        "file" (
                            c(
                                  arg,
                                "size" arg,
                                "files" arg
                            )
                        ).as(:oneline),
                        "log-name" (arg | "all") (
                            c(
                                c(
                                  "none",
                                  "terse",
                                  "brief",
                                  "detail",
                                  "extensive"
                                ),
                                c(
                                  "file-logging",
                                  "no-file-logging"
                                )
                            )
                        ),
                        "log-type" (("debug" | "info" | "notice")) (
                            c(
                                c(
                                  "none",
                                  "terse",
                                  "brief",
                                  "detail",
                                  "extensive"
                                ),
                                c(
                                  "file-logging",
                                  "no-file-logging"
                                )
                            )
                        )
                    )
                )
            )
        ),
        "enable"
    )
end

rule(:smid_maintain_subscriber_type) do
    c(
        "interface-delete"
    )
end

rule(:smid_traceoptions_type) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "flag" (("database" | "ui" | "general" | "session-db" | "server" | "issu" | "all")).as(:oneline)
    )
end

rule(:smihelperd_type) do
    c(
        "traceoptions" (
          smihelperd_traceoptions_type
        )
    )
end

rule(:smihelperd_traceoptions_type) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "flag" (("sdb" | "general" | "ui" | "snmp" | "all")).as(:oneline)
    )
end

rule(:smpl_analyzer_type) do
  arg.as(:arg) (
    c(
        "input" (
          smpl_analyzer_input_type
        ),
        "output" (
          smpl_analyzer_output_type
        )
    )
  )
end

rule(:smpl_analyzer_input_type) do
    c(
        "rate" arg,
        "maximum-packet-length" arg,
        "ingress" (
          smpl_analyzer_ingress_type
        ),
        "egress" (
          smpl_analyzer_egress_type
        )
    )
end

rule(:smpl_analyzer_egress_type) do
    c(
        "interface" (
          analyzer_egress_interface_type
        ),
        "routing-instance" (
          analyzer_egress_routing_instance_type
        ),
        "vlan" (
          analyzer_egress_vlan_type
        ),
        "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 | "all").as(:arg)
end

rule(:analyzer_egress_routing_instance_type) do
  arg.as(:arg) (
    c(
        "vlan" (
          analyzer_egress_vlan_type
        ),
        "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(
        "interface" (
          analyzer_ingress_interface_type
        ),
        "routing-instance" (
          analyzer_ingress_routing_instance_type
        ),
        "vlan" (
          analyzer_ingress_vlan_type
        ),
        "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 | "all").as(:arg)
end

rule(:analyzer_ingress_routing_instance_type) do
  arg.as(:arg) (
    c(
        "vlan" (
          analyzer_ingress_vlan_type
        ),
        "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(
          "interface" (
            interface_name
          ),
          "ip-address" (
            ipv4addr
          ),
          "next-hop-group" arg,
          "routing-instance" (
            output_routing_instance_type
          ),
          "vlan" (
            pm_rspan_vlan
          ),
          "bridge-domain" (
            pm_rspan_bridge_domain
          )
        )
    )
end

rule(:output_routing_instance_type) do
  arg.as(:arg) (
    c(
        "ip-address" (
          ipv4addr
        ),
        "vlan" (
          pm_rspan_vlan
        ),
        "bridge-domain" (
          pm_rspan_bridge_domain
        )
    )
  )
end

rule(:snmp_scripts_file_type) do
  arg.as(:arg) (
    c(
        "oid" arg (
            c(
                "priority" arg
            )
        ),
        "source" arg,
        "python-script-user" arg,
        "refresh",
        "refresh-from" arg,
        "checksum" (
            c(
                "md5" arg,
                "sha1" arg,
                "sha-256" arg
            )
        )
    )
  )
end

rule(:soft_gre_tunnel_group_object) do
  arg.as(:arg) (
    c(
        "source-address" (
          ipaddr
        ),
        "destination-networks" (
          soft_gre_destination_network_object
        ),
        "service-interface" (
          interface_unit
        ),
        "tunnel-idle-timeout" arg,
        "dynamic-profile" arg
    )
  )
end

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

rule(:software_datapath_traceoptions) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        ),
        "flag" (("ager" | "commands" | "configuration" | "flow" | "init" | "ipv6-router-advertisement" | "memory" | "redundancy" | "reassembly" | "buffering" | "all")).as(:oneline)
    )
end

rule(:sonet_options_type) do
    c(
        "vtmapping" (
          ("klm" | "itu-t")
        ),
        "fcs" (
          ("32" | "16")
        ),
        "path-trace" arg,
        "loopback" (
          ("local" | "remote")
        ),
        "trigger" (
            c(
                "lol" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "pll" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "lof" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "los" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "ais-l" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "rfi-l" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "ber-sd" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ),
                "ber-sf" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ),
                "ais-p" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "lop-p" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "rfi-p" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "uneq-p" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "plm-p" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "locd" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline),
                "lcdp" (
                    c(
                        c(
                          "ignore",
                          "hold-time" (
                              c(
                                  "up" arg,
                                  "down" arg
                              )
                          ).as(:oneline)
                        )
                    )
                ).as(:oneline)
            )
        ),
        "aps" (
          aps_type
        ),
        c(
          "payload-scrambler" (
              c(
                    arg
              )
          ).as(:oneline),
          "no-payload-scrambler"
        ),
        "z0-increment",
        "no-z0-increment",
        "loop-timing",
        "no-loop-timing",
        "bytes" (
            c(
                "e1-quiet" arg,
                "f1" arg,
                "f2" arg,
                "s1" arg,
                "z3" arg,
                "z4" arg,
                "c2" arg
            )
        ),
        "rfc-2615",
        "aggregate" (
          interface_device
        ),
        "mpls" (
          mpls_ifd_options
        )
    )
end

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

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

rule(:srd_ev_action_object) do
    c(
        c(
          "acquire-mastership",
          "release-mastership",
          "release-mastership-force",
          "release-mastership-if-standby-clear",
          "broadcast-warning"
        ),
        "add-static-route" (
          srd_route_add_object
        ),
        "delete-static-route" (
          srd_route_delete_object
        )
    )
end

rule(:srd_events_object) do
  arg.as(:arg) (
    c(
        "monitor" (
            c(
                "link-down" arg,
                "process" (
                    c(
                        "routing" (
                            c(
                                "restart",
                                "abort"
                            )
                        )
                    )
                ),
                "peer" (
                    c(
                        c(
                          "mastership-release",
                          "mastership-acquire"
                        )
                    )
                )
            )
        )
    )
  )
end

rule(:srd_route_add_object) do
  arg.as(:arg) (
    c(
        c(
          "next-hop" arg,
          "receive"
        ),
        "routing-instance" arg
    )
  )
end

rule(:srd_route_delete_object) do
  arg.as(:arg) (
    c(
        "routing-instance" arg
    )
  )
end

rule(:srd_rs_id_object) do
  arg.as(:arg) (
    c(
        "redundancy-group" arg,
        "redundancy-policy" arg,
        "keepalive" arg,
        "hold-time" arg,
        "healthcheck-timer-interval" arg
    )
  )
end

rule(:srd_traceoptions_object) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        ),
        "flag" (("config" | "connect" | "route" | "ssd" | "snmp" | "system" | "opcmd" | "state-machine" | "kcom" | "database" | "swithover" | "stateful-sync" | "redundancy-group" | "all")).as(:oneline)
    )
end

rule(:ssd_traceoptions_type) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        ),
        "flag" (("infrastructure" | "server" | "routing-instance" | "client-management" | "interfaces-management" | "route-management" | "nexthop-management" | "firewall-management" | "nexthop-group-management" | "cli" | "cfg" | "all")).as(:oneline)
    )
end

rule(:ssl_initiation_config) do
    c(
        "profile" arg (
            c(
                "enable-flow-tracing",
                "protocol-version" (
                  ("all" | "ssl3" | "tls1" | "tls11" | "tls12")
                ),
                "preferred-ciphers" (
                  ("strong" | "medium" | "weak" | "custom")
                ),
                "custom-ciphers" (
                  ("rsa-with-rc4-128-md5" | "rsa-with-rc4-128-sha" | "rsa-with-des-cbc-sha" | "rsa-with-3des-ede-cbc-sha" | "rsa-with-aes-128-cbc-sha" | "rsa-with-aes-256-cbc-sha" | "rsa-export-with-rc4-40-md5" | "rsa-export-with-des40-cbc-sha" | "rsa-export1024-with-des-cbc-sha" | "rsa-export1024-with-rc4-56-md5" | "rsa-export1024-with-rc4-56-sha" | "rsa-with-null-md5" | "rsa-with-null-sha")
                ),
                "enable-session-cache",
                "trusted-ca" (
                      ("all" | arg)
                ),
                "client-certificate" arg,
                "actions" (
                    c(
                        "ignore-server-auth-failure",
                        "crl" (
                            c(
                                "disable",
                                "if-not-present" (
                                  ("allow" | "drop")
                                ),
                                "ignore-hold-instruction-code"
                            )
                        )
                    )
                )
            )
        )
    )
end

rule(:ssl_proxy_config) do
    c(
        "global-config" (
            c(
                "session-cache-timeout" arg
            )
        ),
        "profile" arg (
            c(
                "enable-flow-tracing",
                "protocol-version" (
                  ("all" | "ssl3" | "tls1" | "tls11" | "tls12")
                ),
                "preferred-ciphers" (
                  ("strong" | "medium" | "weak" | "custom")
                ),
                "custom-ciphers" (
                  ("rsa-with-rc4-128-md5" | "rsa-with-rc4-128-sha" | "rsa-with-des-cbc-sha" | "rsa-with-3des-ede-cbc-sha" | "rsa-with-aes-128-cbc-sha" | "rsa-with-aes-256-cbc-sha" | "rsa-export-with-rc4-40-md5" | "rsa-export-with-des40-cbc-sha" | "rsa-export1024-with-des-cbc-sha" | "rsa-export1024-with-rc4-56-md5" | "rsa-export1024-with-rc4-56-sha" | "rsa-with-null-md5" | "rsa-with-null-sha")
                ),
                "enable-session-cache",
                "trusted-ca" (
                      ("all" | arg)
                ),
                "root-ca" arg,
                "whitelist" arg,
                "actions" (
                    c(
                        "ignore-server-auth-failure",
                        "log" (
                            c(
                                "all",
                                "sessions-dropped",
                                "sessions-allowed",
                                "sessions-ignored",
                                "sessions-whitelisted",
                                "errors",
                                "warning",
                                "info"
                            )
                        ),
                        "crl" (
                            c(
                                "disable",
                                "if-not-present" (
                                  ("allow" | "drop")
                                ),
                                "ignore-hold-instruction-code"
                            )
                        ),
                        "renegotiation" (
                          ("allow" | "allow-secure" | "drop")
                        ),
                        "disable-session-resumption"
                    )
                )
            )
        )
    )
end

rule(:ssl_termination_config) do
    c(
        "profile" arg (
            c(
                "enable-flow-tracing",
                "protocol-version" (
                  ("all" | "ssl3" | "tls1" | "tls11" | "tls12")
                ),
                "preferred-ciphers" (
                  ("strong" | "medium" | "weak" | "custom")
                ),
                "custom-ciphers" (
                  ("rsa-with-rc4-128-md5" | "rsa-with-rc4-128-sha" | "rsa-with-des-cbc-sha" | "rsa-with-3des-ede-cbc-sha" | "rsa-with-aes-128-cbc-sha" | "rsa-with-aes-256-cbc-sha" | "rsa-export-with-rc4-40-md5" | "rsa-export-with-des40-cbc-sha" | "rsa-export1024-with-des-cbc-sha" | "rsa-export1024-with-rc4-56-md5" | "rsa-export1024-with-rc4-56-sha" | "rsa-with-null-md5" | "rsa-with-null-sha")
                ),
                "enable-session-cache",
                "trusted-ca" (
                      ("all" | arg)
                ),
                "server-certificate" arg
            )
        )
    )
end

rule(:ssl_traceoptions) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "level" (
          ("brief" | "detail" | "extensive" | "verbose")
        ),
        "flag" (("cli-configuration" | "termination" | "initiation" | "proxy" | "selected-profile" | "all")).as(:oneline)
    )
end

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

rule(:stp_trace_options) do
    c(
        "file" (
          trace_file_type
        ),
        "flag" (("events" | "bpdu" | "timers" | "port-information-state-machine" | "port-receive-state-machine" | "port-role-select-state-machine" | "port-role-transit-state-machine" | "port-state-transit-state-machine" | "port-migration-state-machine" | "port-transmit-state-machine" | "topology-change-state-machine" | "bridge-detection-state-machine" | "state-machine-variables" | "ppmd" | "all-failures" | "all")) (
            c(
                "disable"
            )
        ).as(:oneline)
    )
end

rule(:subscription_type) do
    c(
        arg,
        "ct0" arg,
        "ct1" arg,
        "ct2" arg,
        "ct3" arg
    )
end

rule(:svc_ike_policy) do
  arg.as(:arg) (
    c(
        "description" arg,
        "mode" (
          ("main" | "aggressive")
        ),
        "version" (
          ("1" | "2")
        ),
        "proposals" arg,
        "local-id" (
            c(
                c(
                  "ipv4_addr" (
                    ipv4addr
                  ),
                  "fqdn" arg,
                  "key-id" arg,
                  "ipv6-addr" (
                    ipv6addr
                  )
                )
            )
        ).as(:oneline),
        "certificate-policy-oids" arg,
        "local-certificate" arg,
        "peer-certificate-type" (
          ("pkcs7" | "x509-signature")
        ),
        "remote-id" (
            c(
                "any-remote-id",
                "ipv4_addr" (
                  ipv4addr
                ),
                "fqdn" arg,
                "key-id" arg,
                "ipv6-addr" (
                  ipv6addr
                )
            )
        ),
        "pre-shared-key" (
            c(
                c(
                  "ascii-text" arg,
                  "hexadecimal" arg
                )
            )
        ).as(:oneline),
        "respond-bad-spi" (
            c(
                  arg
            )
        ).as(:oneline)
    )
  )
end

rule(:sw_rule_object) do
  arg.as(:arg) (
    c(
        "match-direction" (
          ("input" | "output")
        ),
        "term" arg (
            c(
                "then" (
                    c(
                        c(
                          "ds-lite" arg,
                          "v6rd" arg
                        )
                    )
                )
            )
        )
    )
  )
end

rule(:syslog_object) do
  (("any" | "authorization" | "daemon" | "ftp" | "ntp" | "security" | "kernel" | "user" | "dfc" | "external" | "firewall" | "pfe" | "conflict-log" | "change-log" | "interactive-commands")).as(:arg) (
    c(
        c(
          "any",
          "emergency",
          "alert",
          "critical",
          "error",
          "warning",
          "notice",
          "info",
          "none"
        )
    )
  ).as(:oneline)
end

rule(:system_id_ip_map) do
  arg.as(:arg) (
    c(
        "ip-address" (
          ipv4prefix
        )
    )
  )
end

rule(:tacplus_server_object) do
  arg.as(:arg) (
    c(
        "port" arg,
        "secret" (
          unreadable
        ),
        "timeout" arg,
        "single-connection",
        "source-address" (
          hostname
        )
    )
  )
end

rule(:tdir_netmon_object) do
    c(
        "traceoptions" (
          tdir_netmon_traceoptions_object
        ),
        "profile" (
          tdir_netmon_profile_object
        ),
        "source-interface" (
          tdir_netmon_src_iface
        )
    )
end

rule(:tdir_netmon_profile_object) do
  arg.as(:arg) (
    c(
        c(
          "http" (
            tdir_http_probe_object
          ),
          "icmp",
          "tcp" (
            tdir_tcp_probe_object
          ),
          "ssl-hello" (
            tdir_ssl_hello_probe_object
          ),
          "custom" (
            tdir_netmon_custom_probe_object
          )
        ),
        "probe-interval" arg,
        "failure-retries" arg,
        "recovery-retries" arg
    )
  )
end

rule(:tdir_http_probe_object) do
    c(
        "port" arg,
        "url" arg,
        "method" (
          ("get" | "options")
        ),
        "hostname" arg
    )
end

rule(:tdir_netmon_custom_probe_object) do
    c(
        "protocol" (
          ("tcp" | "udp")
        ),
        "cmd" (
          tdir_netmon_custom_probe_command_object
        )
    )
end

rule(:tdir_netmon_custom_probe_command_object) do
  arg.as(:arg) (
    c(
        "port" arg,
        "default-real-service-status" (
          ("down" | "up")
        ),
        "send" (
          tdir_netmon_custom_probe_send_object
        ),
        "expect" (
          tdir_netmon_custom_probe_expect_object
        ).as(:oneline)
    )
  )
end

rule(:tdir_netmon_custom_probe_expect_object) do
    c(
        c(
          "ascii" (
            tdir_netmon_cust_probe_ascii_expect_obj
          ).as(:oneline),
          "binary" (
            tdir_netmon_cust_probe_binary_expect_obj
          ).as(:oneline)
        )
    ).as(:oneline)
end

rule(:tdir_netmon_cust_probe_ascii_expect_obj) do
    c(
          arg,
        "offset" (
          tdir_netmon_cust_probe_expect_offset_obj
        ),
        "real-service-action" (
          ("up" | "down")
        )
    ).as(:oneline)
end

rule(:tdir_netmon_cust_probe_binary_expect_obj) do
    c(
          arg,
        "offset" (
          tdir_netmon_cust_probe_expect_offset_obj
        ),
        "real-service-action" (
          ("up" | "down")
        )
    ).as(:oneline)
end

rule(:tdir_netmon_cust_probe_expect_offset_obj) do
    c(
        arg,
        "length" arg
    ).as(:oneline)
end

rule(:tdir_netmon_custom_probe_send_object) do
    c(
        c(
          "ascii" arg,
          "binary" arg
        )
    ).as(:oneline)
end

rule(:tdir_netmon_src_iface) do
  arg.as(:arg) (
    c(
        "family" (
            c(
                "inet" (
                    c(
                        "address" (
                          ipv4addr
                        )
                    )
                ),
                "inet6" (
                    c(
                        "address" (
                          ipv6addr
                        )
                    )
                )
            )
        )
    )
  )
end

rule(:tdir_netmon_traceoptions_object) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable"
            )
        ).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        ),
        "flag" (("all-real-services" | "messages" | "probe" | "inter-thread" | "database" | "file-descriptor-queue" | "probe-infra" | "all")).as(:oneline),
        "monitor" arg (
            c(
                "group-name" arg,
                "real-services-name" arg
            )
        )
    )
end

rule(:tdir_service_load_balance_object) do
    c(
        "traceoptions" (
          tdir_traceoptions_object
        ),
        "route-hold-timer" arg,
        "instance" (
          tdir_slb_instance_object
        )
    )
end

rule(:tdir_slb_instance_object) do
  arg.as(:arg) (
    c(
        "interface" (
          interface_name
        ),
        "server-inet-bypass-filter" arg,
        "server-inet6-bypass-filter" arg,
        "client-interface" (
          interface_unit
        ),
        "server-interface" (
          interface_unit
        ),
        "client-vrf" arg,
        "server-vrf" arg,
        "group" (
          tdir_slb_group_object
        ),
        "real-service" (
          tdir_real_service_object
        ),
        "virtual-service" (
          tdir_virtual_service_object
        )
    )
  )
end

rule(:tdir_real_service_object) do
  arg.as(:arg) (
    c(
        "address" (
          ipaddr
        ),
        "admin-down"
    )
  )
end

rule(:tdir_slb_group_object) do
  arg.as(:arg) (
    c(
        "real-services" arg,
        "routing-instance" arg,
        "health-check-interface-subunit" arg,
        "network-monitoring-profile" arg,
        "real-service-rejoin-options" (
          tdir_auto_rejoin_object
        )
    )
  )
end

rule(:tdir_auto_rejoin_object) do
    c(
        "no-auto-rejoin"
    )
end

rule(:tdir_ssl_hello_probe_object) do
    c(
        "port" arg,
        "version" (
          ("2" | "3")
        )
    )
end

rule(:tdir_tcp_probe_object) do
    c(
        "port" arg
    )
end

rule(:tdir_traceoptions_object) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        ),
        "flag" (("normal" | "config" | "connect" | "health" | "parse" | "probe" | "route" | "snmp" | "statistics" | "system" | "operational-commands" | "filter" | "all")).as(:oneline)
    )
end

rule(:tdir_virtual_service_object) do
  arg.as(:arg) (
    c(
        "mode" (
          ("layer2-direct-server-return" | "direct-server-return" | "translated")
        ),
        "address" (
          ipaddr
        ),
        "route-metric" arg,
        "rebalance-threshold" arg,
        "routing-instance" arg,
        "service" (
          tdir_virtual_service_svc_object
        ),
        "server-interface" (
          interface_unit
        ),
        "group" arg,
        "load-balance-method" (
            c(
                c(
                  "hash" (
                      c(
                          "hash-key" (
                            tdir_virtual_service_lb_hash_method_obj
                          )
                      )
                  ),
                  "random"
                )
            )
        )
    )
  )
end

rule(:tdir_virtual_service_lb_hash_method_obj) do
    c(
        "source-ip",
        "destination-ip",
        "protocol"
    )
end

rule(:tdir_virtual_service_svc_object) do
  arg.as(:arg) (
    c(
        "virtual-port" arg,
        "server-listening-port" arg,
        "protocol" arg,
        "include-real-server-ips-in-server-filter"
    )
  )
end

rule(:te_class_object) do
    c(
        "traffic-class" (
          ("ct0" | "ct1" | "ct2" | "ct3")
        ),
        "priority" arg
    ).as(:oneline)
end

rule(:three_color_policer_type) do
  arg.as(:arg) (
    c(
        "filter-specific",
        "logical-interface-policer",
        "physical-interface-policer",
        "shared-bandwidth-policer",
        "action" (
            c(
                "loss-priority" (
                  three_color_policer_action
                ).as(:oneline)
            )
        ),
        c(
          "single-rate" (
              c(
                  c(
                    "color-blind",
                    "color-aware"
                  ),
                  "committed-information-rate" arg,
                  "committed-burst-size" arg,
                  "excess-burst-size" arg
              )
          ),
          "single-packet-rate" (
              c(
                  c(
                    "color-blind",
                    "color-aware"
                  ),
                  "committed-information-pps" arg,
                  "committed-packet-burst" arg,
                  "excess-packet-burst" arg
              )
          ),
          "two-rate" (
              c(
                  c(
                    "color-blind",
                    "color-aware"
                  ),
                  "committed-information-rate" arg,
                  "committed-burst-size" arg,
                  "peak-information-rate" arg,
                  "peak-burst-size" arg,
                  "aggregate-policing" (
                      c(
                          "policer" arg (
                              c(
                                  "aggregate-sharing-mode" (
                                    ("hybrid")
                                  )
                              )
                          )
                      )
                  )
              )
          ),
          "two-packet-rate" (
              c(
                  c(
                    "color-blind",
                    "color-aware"
                  ),
                  "committed-information-pps" arg,
                  "committed-packet-burst" arg,
                  "peak-information-pps" arg,
                  "peak-packet-burst" arg
              )
          )
        )
    )
  )
end

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

rule(:to_fabric_object) do
    c(
        "except"
    )
end

rule(:trace_file_type) do
    c(
          arg,
        "replace",
        "size" arg,
        "files" arg,
        "no-stamp",
        "world-readable",
        "no-world-readable"
    ).as(:oneline)
end

rule(:transaction_method_type) do
  (("method-invite" | "method-options" | "method-refer" | "method-subscribe" | "method-publish" | "method-message" | "method-register")).as(:arg)
end

rule(:transaction_policy_type) do
  arg.as(:arg) (
    c(
        "term" arg (
            c(
                "from" (
                  new_transaction_from_type
                ),
                "then" (
                  new_transaction_then_type
                )
            )
        )
    )
  )
end

rule(:new_transaction_then_type) do
    c(
        "accept",
        "reject",
        "route" (
          route_action
        ),
        "trace",
        "admission-control" arg,
        "message-manipulation" (
            c(
                "forward-manipulation" arg,
                "reverse-manipulation" arg
            )
        ),
        "signaling-realm" arg,
        "on-3xx-response" (
            c(
                c(
                  "recursion-limit" arg
                )
            )
        )
    )
end

rule(:route_action) do
    c(
        "next-hop" (
            c(
                c(
                  "address" (
                    routing_destination_address
                  ),
                  "request-uri",
                  "sip-based"
                )
            )
        ),
        "egress-service-point" arg,
        "server-cluster" arg
    )
end

rule(:transport_protocol) do
    c(
        c(
          "udp",
          "tcp"
        )
    )
end

rule(:tty_port_object) do
    c(
        "authentication-order" (
          ("radius" | "tacplus" | "password")
        ),
        "log-out-on-disconnect",
        "port-type" (
          ("rj45" | "mini-usb")
        ),
        "disable",
        "insecure",
        "speed" (
          ("1200" | "2400" | "4800" | "9600" | "19200" | "38400" | "57600" | "115200")
        ),
        "type" (
          ("ansi" | "vt100" | "small-xterm" | "xterm")
        ),
        "silent-with-modem"
    )
end

rule(:tunable_object) do
  arg.as(:arg) (
    c(
        "tunable-value" arg
    )
  )
end

rule(:tunnel_end_point) do
  arg.as(:arg) (
    c(
        c(
          "ipv6" (
              c(
                  "source-address" (
                    ipv6addr
                  ),
                  "destination-address" (
                    ipv6addr
                  )
              )
          ),
          "ipv4" (
              c(
                  "source-address" (
                    ipv4addr
                  ),
                  "destination-address" (
                    ipv4addr
                  )
              )
          )
        ),
        c(
          "gre" (
              c(
                  "key" arg
              )
          ),
          "gre-in-udp" (
              c(
                  "source-port" arg,
                  "destination-port" arg,
                  "key" arg
              )
          )
        )
    )
  )
end

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

rule(:twamp_authentication_key_chain) do
  arg.as(:arg) (
    c(
        "key-id" arg (
            c(
                "secret" arg
            )
        )
    )
  )
end

rule(:unified_edge_gateway_diameter) do
    c(
        "network-element" arg (
            c(
                "session-pics" (
                  unified_edge_gateway_diameter_ne_session_pics
                )
            )
        )
    )
end

rule(:unified_edge_gateway_diameter_ne_session_pics) do
    c(
        "group" arg (
            c(
                "session-pic" arg
            )
        )
    )
end

rule(:unified_edge_ggsn_pgw_system) do
    c(
        "pfes" (
            c(
                "interface" arg (
                    c(
                        "service-mode" (
                          ("maintenance")
                        )
                    )
                )
            )
        ),
        "session-pics" (
            c(
                "interface" arg (
                    c(
                        "service-mode" (
                          ("maintenance")
                        )
                    )
                )
            )
        ),
        "service-pics" (
            c(
                "interface" arg (
                    c(
                        "service-mode" (
                          ("maintenance")
                        )
                    )
                )
            )
        )
    )
end

rule(:unified_edge_mobile_options) do
    c(
        "traceoptions" (
          mobiled_traceoptions
        )
    )
end

rule(:mobiled_traceoptions) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "flag" (("configuration" | "protocol" | "init" | "error" | "all")) (
            c(
                "send",
                "receive",
                "detail",
                "disable"
            )
        ).as(:oneline)
    )
end

rule(:unified_edge_pcef) do
    c(
        "traceoptions" (
          pcef_traceoptions
        ),
        "event-trigger-profiles" (
            c(
                  evt_trigger_profile
            )
        ),
        "flow-descriptions" (
            c(
                  pcc_flow
            )
        ),
        "pcc-action-profiles" (
            c(
                  pcc_action_profile
            )
        ),
        "pcc-rules" (
            c(
                  pcc_rule
            )
        ),
        "pcc-rulebases" (
            c(
                  pcc_rulebase
            )
        ),
        "profiles" (
            c(
                  pcef_profiles
            )
        ),
        "pcc-time-of-day-profiles" (
            c(
                  pcef_time_of_day_profile
            )
        )
    )
end

rule(:pcef_time_of_day_profile) do
  arg.as(:arg) (
    c(
        "rule-activation-time" (
          pcef_tod_time_type
        ),
        "rule-deactivation-time" (
          pcef_tod_time_type
        )
    )
  )
end

rule(:pcef_tod_time_type) do
    c(
        c(
          "SUNDAY",
          "MONDAY",
          "TUESDAY",
          "WEDNESDAY",
          "THURSDAY",
          "FRIDAY",
          "SATURDAY",
          "DAY1",
          "DAY2",
          "DAY3",
          "DAY4",
          "DAY5",
          "DAY6",
          "DAY7",
          "DAY8",
          "DAY9",
          "DAY10",
          "DAY11",
          "DAY12",
          "DAY13",
          "DAY14",
          "DAY15",
          "DAY16",
          "DAY17",
          "DAY18",
          "DAY19",
          "DAY20",
          "DAY21",
          "DAY22",
          "DAY23",
          "DAY24",
          "DAY25",
          "DAY26",
          "DAY27",
          "Last-day-of-month"
        ),
        c(
          "JANUARY",
          "FEBRUARY",
          "MARCH",
          "APRIL",
          "MAY",
          "JUNE",
          "JULY",
          "AUGUST",
          "SEPTEMBER",
          "OCTOBER",
          "NOVEMBER",
          "DECEMBER"
        ),
          time
    )
end

rule(:unified_edge_sgw_system) do
    c(
        "pfes" (
            c(
                "interface" arg (
                    c(
                        "service-mode" (
                          ("maintenance")
                        )
                    )
                )
            )
        ),
        "session-pics" (
            c(
                "interface" arg (
                    c(
                        "service-mode" (
                          ("maintenance")
                        )
                    )
                )
            )
        )
    )
end

rule(:unified_edge_tdf) do
  arg.as(:arg) (
    c(
        "service-mode" (
          ("maintenance")
        ),
        "system" (
          unified_edge_tdf_system
        ),
        "call-rate-statistics" (
            c(
                "interval" arg,
                "history" arg
            )
        ),
        "traceoptions" (
          mobile_smd_traceoptions
        ),
        "cac" (
            c(
                "maximum-subscribers" arg,
                "maximum-subscribers-trap-percentage" arg,
                "memory" (
                    c(
                        "percentage" arg
                    )
                ),
                "cpu" (
                    c(
                        "percentage" arg
                    )
                )
            )
        ),
        "charging" (
            c(
                "traceoptions" (
                  charging_traceoptions
                ),
                "charging-profiles" (
                    c(
                          juniper_charging_profiles
                    )
                ),
                "transport-profiles" (
                    c(
                          juniper_transport_profiles
                    )
                )
            )
        ),
        "domains" (
            c(
                  tdf_domain
            )
        ),
        "domain-selection" (
            c(
                "term" arg (
                    c(
                        "from" (
                          domain_sel_match_object
                        ),
                        "then" (
                            c(
                                "domain" arg,
                                "pcef-profile" arg
                            )
                        )
                    )
                )
            )
        ),
        "aaa" (
            c(
                "clients" (
                    c(
                        arg
                    )
                ),
                "snoop-segments" (
                    c(
                        arg
                    )
                )
            )
        )
    )
  )
end

rule(:domain_sel_match_object) do
    c(
        "client" arg,
        "snoop-segment" arg,
        "user-name" (
            c(
                c(
                  "equals" (
                      c(
                            arg
                      )
                  ),
                  "has-prefix" (
                      c(
                            arg
                      )
                  ),
                  "has-suffix" (
                      c(
                            arg
                      )
                  ),
                  "matches" (
                      c(
                            arg
                      )
                  )
                )
            )
        ).as(:oneline),
        "nas-ip-address" (
            c(
                "equals" (
                    c(
                          ipv4prefix
                    )
                )
            )
        ).as(:oneline),
        "calling-station-id" (
            c(
                c(
                  "equals" (
                      c(
                            arg
                      )
                  ),
                  "has-prefix" (
                      c(
                            arg
                      )
                  ),
                  "has-suffix" (
                      c(
                            arg
                      )
                  ),
                  "matches" (
                      c(
                            arg
                      )
                  )
                )
            )
        ).as(:oneline),
        "called-station-id" (
            c(
                c(
                  "equals" (
                      c(
                            arg
                      )
                  ),
                  "has-prefix" (
                      c(
                            arg
                      )
                  ),
                  "has-suffix" (
                      c(
                            arg
                      )
                  ),
                  "matches" (
                      c(
                            arg
                      )
                  )
                )
            )
        ).as(:oneline),
        "class" (
            c(
                c(
                  "equals" (
                      c(
                            arg
                      )
                  ),
                  "has-prefix" (
                      c(
                            arg
                      )
                  ),
                  "has-suffix" (
                      c(
                            arg
                      )
                  ),
                  "matches" (
                      c(
                            arg
                      )
                  )
                )
            )
        ).as(:oneline),
        "threegpp-imsi" (
            c(
                c(
                  "equals" (
                      c(
                            arg
                      )
                  ),
                  "has-prefix" (
                      c(
                            arg
                      )
                  ),
                  "has-suffix" (
                      c(
                            arg
                      )
                  ),
                  "matches" (
                      c(
                            arg
                      )
                  )
                )
            )
        ).as(:oneline),
        "framed-ip-address" (
            c(
                "equals" (
                    c(
                          ipv4prefix
                    )
                )
            )
        ).as(:oneline),
        "framed-ipv6-prefix" (
            c(
                "equals" (
                    c(
                          ipv6prefix
                    )
                )
            )
        ).as(:oneline),
        "attribute" arg (
            c(
                "code" arg,
                "vendor-id" arg,
                "format" (
                    c(
                        c(
                          "string" (
                              c(
                                  c(
                                    "equals" (
                                        c(
                                              arg
                                        )
                                    ),
                                    "has-prefix" (
                                        c(
                                              arg
                                        )
                                    ),
                                    "has-suffix" (
                                        c(
                                              arg
                                        )
                                    ),
                                    "matches" (
                                        c(
                                              arg
                                        )
                                    )
                                  )
                              )
                          ),
                          "time" (
                              c(
                                  c(
                                    "equals" (
                                        c(
                                              time
                                        )
                                    ),
                                    "greater-than" (
                                        c(
                                              time
                                        )
                                    ),
                                    "less-than" (
                                        c(
                                              time
                                        )
                                    )
                                  )
                              )
                          ),
                          "integer" (
                              c(
                                  c(
                                    "equals" (
                                        c(
                                            arg
                                        )
                                    ),
                                    "greater-than" (
                                        c(
                                            arg
                                        )
                                    ),
                                    "less-than" (
                                        c(
                                            arg
                                        )
                                    )
                                  )
                              )
                          ),
                          "v4address" (
                              c(
                                  "equals" (
                                      c(
                                            ipv4prefix
                                      )
                                  )
                              )
                          ),
                          "v6prefix" (
                              c(
                                  "equals" (
                                      c(
                                            ipv6prefix
                                      )
                                  )
                              )
                          ),
                          "v6address" (
                              c(
                                  "equals" (
                                      c(
                                            ipv6prefix
                                      )
                                  )
                              )
                          )
                        )
                    )
                ).as(:oneline)
            )
        )
    )
end

rule(:tdf_domain) do
  arg.as(:arg) (
    c(
        "subscriber-type" (
          ("ip" | "ifl")
        ),
        "subscriber-exclude-prefix" (
            c(
                "family" (
                    c(
                        "inet" (
                            c(
                                "network" arg
                            )
                        ),
                        "inet6" (
                            c(
                                "network" arg
                            )
                        )
                    )
                )
            )
        ),
        "pcef-profile" arg,
        "tdf-interface" (
          interface_unit
        ),
        "maximum-bit-rate" (
            c(
                "uplink" arg,
                "downlink" arg
            )
        ),
        "burst-size" (
            c(
                "uplink" arg,
                "downlink" arg
            )
        ),
        "charging-profile" arg,
        "service-mode" (
          ("maintenance")
        ),
        "call-rate-statistics" (
            c(
                "interval" arg,
                "history" arg
            )
        ),
        "ip-subscriber" (
            c(
                "access-interfaces" arg,
                "subscriber-attach-method" (
                  ("radius-accounting" | "packet-triggered" | "pcrf-initiated")
                ),
                "subscription-id" (
                    c(
                        "subscription-id-options" (
                          subscription_id_set
                        ),
                        "constant" (
                            c(
                                  arg
                            )
                        ).as(:oneline),
                        "use-class-regular-expression" arg,
                        "use-class" (
                            c(
                                "regex" arg,
                                "pattern" arg,
                                "subscription-id-type" (
                                  ("imsi" | "msisdn" | "nai" | "sip-uri" | "private")
                                )
                            )
                        )
                    )
                ),
                "immediate-accounting-response" (
                  ("enable" | "disable")
                ),
                "subscriber-address" (
                    c(
                        "inet" (
                            c(
                                "pool" arg
                            )
                        ),
                        "inet6" (
                            c(
                                "pool" arg
                            )
                        )
                    )
                ),
                "maximum-subscribers" arg,
                "idle-timeout" arg,
                "default-local-policy" (
                    c(
                        "flow-action" (
                          ("forward" | "drop")
                        ),
                        "maximum-bit-rate" (
                            c(
                                "uplink" arg,
                                "downlink" arg
                            )
                        ).as(:oneline),
                        "burst-size" (
                            c(
                                "uplink" arg,
                                "downlink" arg
                            )
                        )
                    )
                )
            )
        ),
        "ifl-subscriber" (
            c(
                  tdf_ifl_subscriber
            )
        )
    )
  )
end

rule(:subscription_id_set) do
  arg.as(:arg) (
    c(
        "id-components" (
          ("use-imsi" | "use-msisdn" | "use-nai" | "use-username" | "use-realm" | "use-nas-port" | "use-nas-port-id" | "use-class")
        )
    )
  )
end

rule(:tdf_ifl_subscriber) do
  arg.as(:arg) (
    c(
        "access-interfaces" arg
    )
  )
end

rule(:unified_edge_tdf_system) do
    c(
        "session-pics" (
            c(
                "interface" arg (
                    c(
                        "service-mode" (
                          ("maintenance")
                        )
                    )
                )
            )
        ),
        "service-pics" (
            c(
                "interface" arg (
                    c(
                        "service-mode" (
                          ("maintenance")
                        )
                    )
                )
            )
        )
    )
end

rule(:upgrade_group_fpcs) do
  arg.as(:arg) (
    c(
        "fpcs" arg
    )
  )
end

rule(:upgrade_group_type) do
  arg.as(:arg) (
    c(
        "satellite" arg
    )
  )
end

rule(:urlf_profile_object) do
  arg.as(:arg) (
    c(
        "url-filter-database" arg,
        "template" (
          urlf_template_object
        )
    )
  )
end

rule(:urlf_template_object) do
  arg.as(:arg) (
    c(
        "client-interfaces" (
          interface_unit
        ),
        "server-interfaces" (
          interface_unit
        ),
        "dns-source-interface" (
          interface_unit
        ),
        "dns-routing-instance" (
          (arg | "inet.0")
        ),
        "routing-instance" (
          (arg | "inet.0")
        ),
        "dns-server" (
          ipaddr
        ),
        "dns-resolution-interval" arg,
        "dns-retries" arg,
        "dns-resolution-rate" arg,
        "url-filter-database" arg,
        "term" arg (
            c(
                "from" (
                  urlf_match_object
                ),
                "then" (
                    c(
                        c(
                          "redirect-url" arg,
                          "custom-page" arg,
                          "http-status-code" arg,
                          "tcp-reset",
                          "accept"
                        )
                    )
                )
            )
        )
    )
  )
end

rule(:urlf_match_object) do
    c(
        "src-ip-prefix" (
          ipprefix
        ),
        "dest-ports" arg
    )
end

rule(:urlf_traceoptions_object) do
    c(
        "no-remote-trace",
        "file" (
            c(
                  arg,
                "size" arg,
                "files" arg,
                "world-readable",
                "no-world-readable",
                "match" (
                  regular_expression
                )
            )
        ).as(:oneline),
        "level" (
          ("error" | "warning" | "notice" | "info" | "verbose" | "all")
        ),
        "flag" (("normal" | "config" | "dns" | "timer" | "connect" | "parse" | "statistics" | "system" | "operational-commands" | "filter" | "gencfg" | "routing" | "snmp" | "all")).as(:oneline)
    )
end

rule(:v3_user_config) do
  arg.as(:arg) (
    c(
        c(
          "authentication-md5" (
            auth_object
          ),
          "authentication-sha" (
            auth_object
          ),
          "authentication-none"
        ),
        c(
          "privacy-des" (
            priv_object
          ),
          "privacy-3des" (
            priv_object
          ),
          "privacy-aes128" (
            priv_object
          ),
          "privacy-none"
        )
    )
  )
end

rule(:auth_object) do
    c(
        "authentication-password" arg,
        "authentication-key" (
          unreadable
        )
    )
end

rule(:priv_object) do
    c(
        "privacy-password" arg,
        "privacy-key" (
          unreadable
        )
    )
end

rule(:v6_relay_option_interface_id_type) do
    c(
        "prefix" (
            c(
                "host-name",
                "logical-system-name",
                "routing-instance-name"
            )
        ),
        "use-interface-description" (
          ("logical" | "device")
        ),
        "use-vlan-id",
        "no-vlan-interface-name",
        "include-irb-and-l2",
        "use-option-82" (
          v6_relay_option_cid_rid_action
        ),
        "keep-incoming-interface-id"
    )
end

rule(:v6_relay_option_cid_rid_action) do
    c(
        "strict"
    )
end

rule(:v6_relay_option_remote_id_type) do
    c(
        "prefix" (
            c(
                "host-name",
                "logical-system-name",
                "routing-instance-name"
            )
        ),
        "use-interface-description" (
          ("logical" | "device")
        ),
        "use-vlan-id",
        "no-vlan-interface-name",
        "include-irb-and-l2",
        "use-option-82" (
          v6_relay_option_cid_rid_action
        ),
        "keep-incoming-remote-id"
    )
end

rule(:v6_server_group_type) do
    c(
            c(
                arg
            )
    )
end

rule(:v6rd_object) do
  arg.as(:arg) (
    c(
        "softwire-address" (
          ipv4addr
        ),
        "ipv4-prefix" (
          ipv4prefix
        ),
        "v6rd-prefix" (
          ipv6prefix
        ),
        "mtu-v4" arg
    )
  )
end

rule(:vchassis_trace_file_type) do
    c(
          arg,
        "replace",
        "size" arg,
        "files" arg,
        "no-stamp",
        "world-readable",
        "no-world-readable"
    ).as(:oneline)
end

rule(:version_ipfix_template) do
  arg.as(:arg) (
    c(
        "flow-active-timeout" arg,
        "flow-inactive-timeout" arg,
        "template-id" arg,
        "option-template-id" arg,
        "observation-domain-id" arg,
        "nexthop-learning" (
            c(
                  ("enable" | "disable")
            )
        ),
        "template-refresh-rate" (
            c(
                "packets" arg,
                "seconds" arg
            )
        ),
        "option-refresh-rate" (
            c(
                "packets" arg,
                "seconds" arg
            )
        ),
        c(
          "ipv4-template",
          "ipv6-template",
          "vpls-template",
          "mpls-template" (
              c(
                  "label-position" arg
              )
          ),
          "mpls-ipv4-template" (
              c(
                  "label-position" arg
              )
          )
        ),
        "flow-key" (
            c(
                "flow-direction",
                "vlan-id"
            )
        )
    )
  )
end

rule(:version9_template) do
  arg.as(:arg) (
    c(
        "flow-active-timeout" arg,
        "flow-inactive-timeout" arg,
        "template-id" arg,
        "option-template-id" arg,
        "source-id" arg,
        "nexthop-learning" (
            c(
                  ("enable" | "disable")
            )
        ),
        "template-refresh-rate" (
            c(
                "packets" arg,
                "seconds" arg
            )
        ),
        "option-refresh-rate" (
            c(
                "packets" arg,
                "seconds" arg
            )
        ),
        c(
          "mpls-ipv4-template" (
              c(
                  "label-position" arg
              )
          ),
          "mpls-template" (
              c(
                  "label-position" arg
              )
          ),
          "ipv6-template" (
              c(
                  "nexthop-options" (
                      c(
                          c(
                            "mpls" (
                                c(
                                    "label-position" arg
                                )
                            )
                          )
                      )
                  )
              )
          ),
          "peer-as-billing-template",
          "ipv4-template" (
              c(
                  "nexthop-options" (
                      c(
                          c(
                            "mpls" (
                                c(
                                    "label-position" arg
                                )
                            )
                          )
                      )
                  )
              )
          )
        ),
        "flow-key" (
            c(
                "flow-direction",
                "vlan-id"
            )
        )
    )
  )
end

rule(:virtual_interface_indications_object) do
    c(
        "virtual-interface-up" (
          pgcp_virtual_interface_up_object
        ),
        "virtual-interface-down" (
          pgcp_virtual_interface_down_object
        )
    )
end

rule(:pgcp_virtual_interface_down_object) do
    c(
        "graceful" (
          ("none" | "graceful-905")
        ),
        "administrative" (
          ("forced-905" | "forced-906" | "none")
        ),
        "failure" (
          ("forced-904" | "forced-906" | "none")
        ),
        "link-loss" (
          ("forced-906" | "none")
        )
    )
end

rule(:pgcp_virtual_interface_up_object) do
    c(
        "warm" (
          ("restart-900" | "none")
        ),
        "cancel-graceful" (
          ("none" | "restart-918")
        )
    )
end

rule(:vlan_policy) do
  (arg | "all").as(:arg) (
    c(
        "policy" (
            c(
                arg,
                c(
                  "stateful",
                  "stateless"
                )
            )
        )
    )
  )
end

rule(:vlan_types) do
  arg.as(:arg) (
    c(
        "description" arg,
        c(
          "vlan-id" (
            ("all" | "none" | arg)
          ),
          "vlan-id-list" arg,
          "vlan-tags" (
              c(
                  "outer" arg,
                  "inner" arg
              )
          ).as(:oneline)
        ),
        "interface" ("$junos-interface-name" | arg),
        "l3-interface" (
          interface_unit
        ),
        "no-local-switching",
        "forwarding-options" (
          juniper_ethernet_switching_forwarding_options
        ),
        "multicast-snooping-options" (
          juniper_multicast_snooping_options
        ),
        "switch-options" (
          juniper_protocols_vlan
        ),
        "domain-type" (
          ("bridge")
        ),
        "no-irb-layer-2-copy",
        "service-id" arg,
        "domain-id" arg,
        "mcae-mac-synchronize",
        "no-arp-suppression",
        "mcae-mac-flush",
        "private-vlan" (
          ("isolated" | "community")
        ),
        "isolated-vlan" arg,
        "community-vlans" arg,
        "vxlan" (
            c(
                "ovsdb-managed",
                "vni" arg,
                "multicast-group" (
                  ipv4addr
                ),
                "encapsulate-inner-vlan",
                "decapsulate-accept-inner-vlan",
                "unreachable-vtep-aging-timer" arg,
                "ingress-node-replication"
            )
        )
    )
  )
end

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

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

rule(:vlan_map) do
    c(
        c(
          "push",
          "swap",
          "pop",
          "push-push",
          "swap-push",
          "swap-swap",
          "pop-swap",
          "pop-pop"
        ),
        "tag-protocol-id" arg,
        "inner-tag-protocol-id" arg,
        "vlan-id" (
          ("$junos-vlan-map-id" | arg)
        ),
        "inner-vlan-id" (
          ("$junos-inner-vlan-map-id" | arg)
        )
    )
end

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

rule(:vrrp_group) do
  arg.as(:arg) (
    c(
        c(
          "virtual-address" (
            ipv4addr
          ),
          "virtual-inet6-address" (
            ipv6addr
          )
        ),
        "virtual-link-local-address" (
          ipv6addr
        ),
        "priority" arg,
        "preferred",
        c(
          "advertise-interval" arg,
          "fast-interval" arg,
          "inet6-advertise-interval" arg
        ),
        c(
          "preempt" (
              c(
                  "hold-time" arg
              )
          ),
          "no-preempt"
        ),
        c(
          "accept-data",
          "no-accept-data"
        ),
        "authentication-type" (
          ("md5" | "simple")
        ),
        "authentication-key" (
          unreadable
        ),
        "track" (
            c(
                "priority-hold-time" arg,
                "interface" arg (
                    c(
                        "bandwidth-threshold" arg (
                            c(
                                "priority-cost" arg
                            )
                        ).as(:oneline),
                        "priority-cost" arg
                    )
                ),
                "route" (
                    s(
                            arg,
                      "routing-instance" arg,
                      c(
                        "priority-cost" arg
                      )
                    )
                ).as(:oneline)
            )
        ),
        "vrrp-inherit-from" (
            c(
                "active-interface" (
                  interface_unit
                ),
                "active-group" arg
            )
        ),
        "advertisements-threshold" arg
    )
  )
end

rule(:write_option_82_type) do

end

rule(:juniper_ethernet_options) do
    c(
        "traceoptions" (
            c(
                "file" (
                  trace_file_type
                ),
                "flag" ("parse" | "regex-parse" | "config-internal" | "normal" | "general" | "state" | "task" | "timer" | "krt" | "vlan" | "forwarding-database" | "nexthop" | "interface" | "lib" | "stp" | "filter" | "access-security" | "rtg" | "ip-source-guard" | "analyzer" | "layer2-protocol-tunneling" | "unknown-unicast-forwarding" | "all") (
                    c(
                        "disable"
                    )
                ).as(:oneline)
            )
        ),
        "voip" (
            c(
                "interface" arg (
                    c(
                        "vlan" arg,
                        "forwarding-class" arg
                    )
                )
            )
        ),
        "unknown-unicast-forwarding" (
            c(
                "vlan" arg (
                    c(
                        "interface" (
                          interface_name
                        )
                    )
                )
            )
        ),
        "dot1q-tunneling" (
            c(
                "ether-type" (
                  ("0x8100" | "0x9100" | "0x88a8")
                )
            )
        ),
        "mac-notification" (
            c(
                "notification-interval" arg
            )
        ),
        "interfaces" (
            c(
                "esw-interface" (
                  esw_interface_type
                )
            )
        ),
        "mac-table-aging-time" (
          mac_aging_time_config
        ),
        "nonstop-bridging",
        "static" (
            c(
                "vlan" arg (
                    c(
                        "mac" arg (
                            c(
                                "next-hop" (
                                  interface_name
                                )
                            )
                        ).as(:oneline)
                    )
                )
            )
        ),
        "secure-access-port" (
            c(
                "interface" arg (
                    c(
                        "mac-limit" (
                            c(
                                "limit" arg,
                                "action" (
                                  ("none" | "drop" | "log" | "shutdown")
                                )
                            )
                        ).as(:oneline),
                        "static-ip" (
                          juniper_ip_mac_static
                        ),
                        "allowed-mac" (
                          mac_addr
                        ),
                        "no-allowed-mac-log",
                        "dhcp-trusted",
                        "no-dhcp-trusted",
                        "fcoe-trusted",
                        "no-fcoe-trusted",
                        "persistent-learning"
                    )
                ),
                "vlan" ("all" | "vlan-name") (
                    c(
                        c(
                          "arp-inspection" (
                              c(
                                  "forwarding-class" arg
                              )
                          ).as(:oneline),
                          "no-arp-inspection"
                        ),
                        c(
                          "examine-dhcp" (
                              c(
                                  "forwarding-class" arg
                              )
                          ).as(:oneline),
                          "no-examine-dhcp"
                        ),
                        "examine-fip",
                        "mac-move-limit" (
                            c(
                                "limit" arg,
                                "action" (
                                  ("none" | "drop" | "log" | "shutdown")
                                )
                            )
                        ).as(:oneline),
                        "ip-source-guard",
                        "no-ip-source-guard",
                        "dhcp-option82" (
                          dhcp_option82_type
                        )
                    )
                ),
                "dhcp-snooping-file" (
                    c(
                        "location" (
                          filename
                        ),
                        "write-interval" arg,
                        "timeout" arg
                    )
                )
            )
        ),
        "authentication-whitelist" arg (
            c(
                "vlan-assignment" arg,
                "interface" (
                  interface_name
                )
            )
        ),
        "analyzer" (
          analyzer_type
        ),
        "port-error-disable" (
            c(
                "disable-timeout" arg
            )
        ),
        "bpdu-block" (
            c(
                "interface" ("all" | "name"),
                "disable-timeout" arg
            )
        ),
        "redundant-trunk-group" (
            c(
                "group" arg (
                    c(
                        "preempt-cutover-timer" arg,
                        "description" arg,
                        "interface" arg (
                            c(
                                "primary"
                            )
                        )
                    )
                )
            )
        ),
        "storm-control" (
            c(
                "action-shutdown",
                "interface" ("all" | "name") (
                    c(
                        "bandwidth" arg,
                        "no-broadcast",
                        "no-unknown-unicast",
                        "level" arg,
                        c(
                          "multicast",
                          "no-multicast",
                          "no-registered-multicast",
                          "no-unregistered-multicast"
                        )
                    )
                )
            )
        )
    )
end

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

rule(:mac_aging_time_config) do
    c(
        c(
          "time" arg,
          "unlimited"
        )
    )
end

rule(:juniper_ip_mac_static) do
  arg.as(:arg) (
    c(
        "vlan" arg,
        "mac" (
          mac_addr
        )
    )
  ).as(:oneline)
end

rule(:analyzer_type) do
  arg.as(:arg) (
    c(
        "input" (
          esw_analyzer_input_type
        ),
        "output" (
          esw_analyzer_output_type
        )
    )
  )
end

rule(:esw_analyzer_input_type) do
    c(
        "ingress" (
          esw_analyzer_ingress_type
        ),
        "egress" (
          esw_analyzer_egress_type
        )
    )
end

rule(:esw_analyzer_egress_type) do
    c(
        "interface" (
          analyzer_egress_interface_type
        ),
        "vlan" (
          analyzer_egress_vlan_type
        )
    )
end

rule(:esw_analyzer_ingress_type) do
    c(
        "interface" (
          analyzer_ingress_interface_type
        ),
        "vlan" (
          analyzer_ingress_vlan_type
        )
    )
end

rule(:esw_analyzer_output_type) do
    c(
        c(
          "interface" (
            interface_name
          ),
          "ip-address" (
            ipv4addr
          ),
          "routing-instance" arg,
          "vlan" (
            pm_rspan_vlan
          )
        )
    )
end