;; ! THIS FILE CONTAINS AN INITIALIZATION SCHEME FOR CONFIG READER
;; ! PLEASE DO NOT MODIFY THIS FILE

(version 1000)

(serializator "filters"

    ;;; Defines enumerator without args
    (define "scoring" "Scoring" '("mode"))
    (define "attempts" "Attempts" '("mode"))
    (define "instant" "Instant" '("mode"))
    
    ;;; --- VARs
    (procedure "search/window"
        (arg "l_searchwindow" int)
    )
    
    (procedure "retry"
        (arg "l_retry" uint)
    )
    
    (procedure "score"
        (arg "l_score" uint)
    )
    
    (procedure "bantime" 
        (arg "l_bantime" int)
    )

    (procedure "ignore/hosts" 
        (arg "l_ignore_hosts" vector string)
    )
    
    (procedure "ignore/users" 
        (arg "l_ignore_users" vector string)
    )
    
    (procedure "var"
        (proc "l_filter_sw" '("search/window") (proc-allow '(optional)))
        (proc "l_filter_retry" '("retry") (proc-allow '(optional)))
        (proc "l_filter_score" '("score") (proc-allow '(optional)))
        (proc "l_filter_bantime" '("bantime") (proc-allow '(optional)))
        (proc "l_filter_ign_h" '("ignore/hosts") (proc-allow '(optional)))
        (proc "l_filter_ign_u" '("ignore/users") (proc-allow '(optional)))
    )
    
    (struct "LdFilterOverrides" "var"
        (field "search_win" (f/optional) (f/int '("l_filter_sw" "l_searchwindow")))
        (field "retry_cnt" (f/optional) (f/uint '("l_filter_retry" "l_retry")))
        (field "max_score" (f/optional) (f/uint '("l_filter_score" "l_score")))
        (field "ban_time" (f/optional) (f/int '("l_filter_bantime" "l_bantime")))
        (field "ign_hosts" (f/optional) (f/vector (f/string '("l_filter_ign_h" "l_ignore_hosts"))))
        (field "ign_users" (f/optional) (f/vector (f/string '("l_filter_ign_u" "l_ignore_users"))))
    )
    
    ;;; ---- RULESET < (ANY ALL NOT REGEX LITERAL) + DESCR SCORE, ACTION, SUBPROGS
    
    ;;; --- (ANY ALL NOT REGEX LITERAL)
    (procedure "severity"
        (arg "l_severity" uint)
    )
    (procedure "descr"
        (arg "l_descr" string)
    )
    
    (procedure "literal"
        (arg "l_literal" string)
        (proc "l_literal_severity" '("severity") (proc-allow '(optional)))
        (proc "l_literal_descr" '("descr") (proc-allow '(optional)))
    )
    
    (procedure "regex"
        (arg "l_regex" string)
        (proc "l_literal_severity" '("severity") (proc-allow '(optional)))
        (proc "l_literal_descr" '("descr") (proc-allow '(optional)))
    )
    
    (procedure "any"
        (proc "l_any" '("literal" "regex" "all" "not") (proc-allow '(collection optional)))
    )
    
    (procedure "all"
        (proc "l_all" '("literal" "regex" "any" "not") (proc-allow '(collection optional)))
    )
    
    (procedure "not"
        (proc "l_not" '("literal" "regex" "any" "all") (proc-allow '(collection optional)))
    )
    
    (enum "RuleGroupType" '("any" "all" "not" "regex" "literal")
        (enumopt "any" "Any"
            (vec
                (field anon (f/vector (f/enum '("l_any"))))
            )
        )
        (enumopt "not" "Not"
            (vec
                (field anon (f/vector (f/enum '("l_not"))))
            )
        )
        (enumopt "all" "All"
            (vec
                (field anon (f/vector (f/enum '("l_all"))))
            )
        )
        (enumopt "regex" "Regex"
            (struct none none
                (field "regex" (f/string '("l_regex")))
                (field "score" (f/optional) (f/uint '("l_literal_severity" "l_severity")))
                (field "descr" (f/optional) (f/string '("l_literal_descr" "l_descr")))
            )
        )
        
        (enumopt "literal" "Literal"
            (struct none none
                (field "literal" (f/string '("l_literal")))
                (field "score" (f/optional) (f/uint '("l_literal_severity" "l_severity")))
                (field "descr" (f/optional) (f/string '("l_literal_descr" "l_descr")))
            )
        )
    )
    
    ;;; --- ACTION
    
    (procedure "override"
        (arg "l_override_key" string)
        (arg "l_override_val" string)
    )
    
    (struct "LdMonFilActsOver" "override"
        (field "key" (f/string '("l_override_key")))
        (field "val" (f/string '("l_override_val")))
    )
    
    (procedure "action"
        (arg "l_act_name" string)
        (proc "l_act_override" '("override") (proc-allow '(optional collection)))
    )
    
    (struct "LdMonFilActs" "action"
        (field "action_name" (f/string '("l_act_name")))
        (field "override_map" (f/optional) (f/vector (f/struct '("l_act_override"))))
    )
    
    ;;; --- SUBPROGS
    (procedure "sub-appnames"
        (arg "l_sub_appnames" vector string)
    )
    
    ;;; --- RULESET
    
    (procedure "ruleset"
        (arg "l_ruleset_name" string)
        (proc "l_ruleset_sub_appname" '("sub-appnames") (proc-allow '(optional)))
        (proc "l_ruleset_actions" '("action") (proc-allow '(collection optional)))
        (proc "l_ruleset_group" '("all" "any" "not") (proc-allow '(collection)))
    )
    
    (struct "LdFilterRuleset" "ruleset"
        (field "ruleset_name" (f/string '("l_ruleset_name")))
        (field "sub_appnames" 
            (f/optional) 
            (f/vector 
                (vector/type hashset)
                (f/string '("l_ruleset_sub_appname" "l_sub_appnames"))
            )
        )
        (field "actions" (f/optional) (f/vector (f/struct '("l_ruleset_actions"))))
        (field "rules" (f/vector (f/enum '("l_ruleset_group"))))
    )
    
    ;;; ---- MODE
    (procedure "mode"
        (arg "l_mode" symbol string)
    )
    
    ;;; ---- DEFINE
    (procedure "define"
        (arg "l_define_key" string)
        (arg "l_define_val" string)
    )
    
    (struct "LdFilterDefs" "define"
        (field "key" (f/string '("l_define_key"))) 
        (field "val" (f/string '("l_define_val"))) 
    )
    
    ;;; ---- USE
    (procedure "use"
        (arg "l_use" string)
    )
    
    ;;; ---- USES < SET
    (procedure "set"
        (arg "l_set_title" string)
        (arg "l_set_list" vector string)
    )
    
    (procedure "uses"
        (proc "l_uses" '("set") (proc-allow '(collection optional)))
    )
    
    (struct "LdFilterSets" "set"
        (field "title" (f/string '("l_set_title"))) 
        (field "list" 
            (f/vector 
                (vector/type hashset)
                (f/string '("l_set_list"))
            )
        ) 
    )

    ;;; APPNAME
    (procedure "appname"
        (arg "l_appname" string)
    )
    
    ;;; ---- ROOT
    (rootprocedure
        (proc "l_root_mode" '("mode"))
        (proc "l_root_overrides" '("var") (proc-allow '(optional)))
        (proc "l_root_defines" '("define") (proc-allow '(collection optional)))
        (proc "l_root_sets" '("uses") (proc-allow '(optional)))
        (proc "l_root_use" '("use") (proc-allow '(optional)))
        (proc "l_root_appname" '("appname") (proc-allow '(optional)))
        (proc "l_root_rules" '("ruleset") (proc-allow '(collection)))
    )
    
    (rootstruct "LdFilter"
        (field "mode" (f/string '("l_root_mode" "l_mode")))
        (field "overr_vars" (f/optional) (f/struct '("l_root_overrides")))
        (field "defmap" (f/optional) (f/vector (f/struct '("l_root_defines"))))
        (field "decsets" 
            (f/optional) 
            (f/vector 
                (vector/type hashset)
                (f/struct '("l_root_sets" "l_uses"))
            )
        )
        (field "usesets" (f/optional) (f/string '("l_root_use" "l_use")))
        (field "appname" (f/optional) (f/string '("l_root_appname" "l_appname")))
        (field "rulesets" 
            (f/vector 
                (vector/type hashset)
                (f/struct '("l_root_rules"))
            )
        )
    )
    
)