---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 16),
        },
        Raw {
         content: "rspamd",
         position: (7, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "opt",
        position: (8, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (8, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (8, 17),
        },
        Raw {
         content: "rspamd",
         position: (8, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "postfixCfg",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (9, 16),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (9, 23),
        },
        Raw {
         content: "postfix",
         position: (9, 32),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "bindSocketOpts",
        position: (11, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "config",
         default: None,
        },
        FunctionArgument {
         identifier: "options",
         default: None,
        },
       ],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (12, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "socket",
               position: (13, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (13, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (14, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (14, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (14, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (15, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "localhost:11333",
                    position: (15, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (16, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Socket for this worker to listen on in a format acceptable by rspamd.\n",
                    position: (17, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (13, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mode",
               position: (20, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (20, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (21, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (21, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (21, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (22, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0644",
                    position: (22, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (23, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Mode to set on unix socket",
                    position: (23, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (20, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "owner",
               position: (25, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (25, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (26, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (26, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (26, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (27, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (27, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "user",
                        position: (27, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (28, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Owner to set on unix socket",
                    position: (28, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (25, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (30, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (30, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (31, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (31, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (31, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (32, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (32, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "group",
                        position: (32, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (33, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Group to set on unix socket",
                    position: (33, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (30, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "rawEntry",
               position: (35, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (35, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (36, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (36, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (36, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "internal",
                    position: (37, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (37, 20),
                 },
                ),
               ],
               recursive: false,
               position: (35, 27),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (12, 15),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (40, 5),
           },
           Raw {
            content: "rawEntry",
            position: (40, 12),
           },
          ],
         },
         LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "maybeOption",
               position: (41, 7),
              },
             ],
            },
            Function {
             argument: Some(
              "option",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "optionalString",
               position: (42, 9),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "options",
                 position: (42, 24),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Expression {
                   expression: Variable {
                    identifier: "option",
                    position: (42, 34),
                   },
                  },
                  Raw {
                   content: "isDefined",
                   position: (42, 42),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: " ",
                  position: (42, 53),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "option",
                   position: (42, 56),
                  },
                 },
                 Raw {
                  content: "=",
                  position: (42, 63),
                 },
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (42, 66),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "option",
                       position: (42, 75),
                      },
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                ],
               },
              ],
             },
             position: (41, 21),
            },
           ),
          ],
          target: IfThenElse {
           predicate: UnaryOperation {
            operator: Not,
            operand: FunctionApplication {
             function: Variable {
              identifier: "hasPrefix",
              position: (44, 13),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "/",
                 position: (44, 24),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (44, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "socket",
                  position: (44, 34),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            position: (44, 11),
           },
           then: String {
            parts: [
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (44, 51),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "socket",
                  position: (44, 58),
                 },
                ],
               },
               default: None,
              },
             },
            ],
           },
           else_: String {
            parts: [
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (45, 15),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "socket",
                  position: (45, 22),
                 },
                ],
               },
               default: None,
              },
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "maybeOption",
                position: (45, 31),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "mode",
                   position: (45, 44),
                  },
                 ],
                },
               ],
              },
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "maybeOption",
                position: (45, 52),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "owner",
                   position: (45, 65),
                  },
                 ],
                },
               ],
              },
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "maybeOption",
                position: (45, 74),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "group",
                   position: (45, 87),
                  },
                 ],
                },
               ],
              },
             },
            ],
           },
           position: (44, 7),
          },
          position: (40, 23),
         },
        ),
       ],
       recursive: false,
       position: (11, 45),
      },
      position: (11, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "traceWarning",
        position: (48, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "w",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "x",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (48, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "trace",
            position: (48, 33),
           },
          ],
         },
         default: None,
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "\u{1b}[1;31mwarning: ",
            position: (48, 40),
           },
           Expression {
            expression: Variable {
             identifier: "w",
             position: (48, 58),
            },
           },
           Raw {
            content: "\u{1b}[0m",
            position: (48, 60),
           },
          ],
         },
         Variable {
          identifier: "x",
          position: (48, 66),
         },
        ],
       },
       position: (48, 21),
      },
      position: (48, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "workerOpts",
        position: (50, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "options",
         default: None,
        },
        FunctionArgument {
         identifier: "name",
         default: None,
        },
       ],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (51, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (52, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (52, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (53, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (53, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (53, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (53, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (53, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (54, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (54, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (55, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to run the rspamd worker.",
                    position: (55, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (52, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (57, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (57, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (58, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (58, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (58, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (58, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (58, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (59, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "name",
                  position: (59, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (60, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Name of the worker",
                    position: (60, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (57, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (62, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (62, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (63, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (63, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (63, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (63, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "enum",
                        position: (63, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "normal",
                          position: (64, 12),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "controller",
                          position: (64, 21),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "fuzzy",
                          position: (64, 34),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "rspamd_proxy",
                          position: (64, 42),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "lua",
                          position: (64, 57),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "proxy",
                          position: (64, 63),
                         },
                        ],
                       },
                      ],
                      position: (63, 41),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (66, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The type of this worker. The type <literal>proxy</literal> is\ndeprecated and only kept for backwards compatibility and should be\nreplaced with <literal>rspamd_proxy</literal>.\n",
                    position: (67, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (71, 9),
                   },
                  ],
                 },
                 LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "from",
                       position: (72, 13),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "services.rspamd.workers.\"",
                       position: (72, 21),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "name",
                        position: (72, 49),
                       },
                      },
                      Raw {
                       content: "\".type",
                       position: (72, 54),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "files",
                       position: (73, 13),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "options",
                      position: (73, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "type",
                        position: (73, 29),
                       },
                       Raw {
                        content: "files",
                        position: (73, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "warning",
                       position: (74, 13),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "The option `",
                       position: (74, 24),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "from",
                        position: (74, 38),
                       },
                      },
                      Raw {
                       content: "` defined in ",
                       position: (74, 43),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showFiles",
                         position: (74, 58),
                        },
                        arguments: [
                         Variable {
                          identifier: "files",
                          position: (74, 68),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: " has enum value `proxy` which has been renamed to `rspamd_proxy`",
                       position: (74, 74),
                      },
                     ],
                    },
                   ),
                  ],
                  target: Function {
                   argument: Some(
                    "x",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: IfThenElse {
                    predicate: BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      Variable {
                       identifier: "x",
                       position: (75, 20),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "proxy",
                         position: (75, 26),
                        },
                       ],
                      },
                     ],
                     position: (75, 22),
                    },
                    then: FunctionApplication {
                     function: Variable {
                      identifier: "traceWarning",
                      position: (75, 38),
                     },
                     arguments: [
                      Variable {
                       identifier: "warning",
                       position: (75, 51),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "rspamd_proxy",
                         position: (75, 60),
                        },
                       ],
                      },
                     ],
                    },
                    else_: Variable {
                     identifier: "x",
                     position: (75, 79),
                    },
                    position: (75, 17),
                   },
                   position: (75, 14),
                  },
                  position: (71, 17),
                 },
                ),
               ],
               recursive: false,
               position: (62, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "bindSockets",
               position: (77, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (77, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (78, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (78, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (78, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (78, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "either",
                        position: (78, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (78, 43),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "str",
                         position: (78, 49),
                        },
                       ],
                      },
                      default: None,
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (78, 54),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "submodule",
                          position: (78, 60),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Variable {
                        identifier: "bindSocketOpts",
                        position: (78, 70),
                       },
                      ],
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (79, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (79, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (80, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of sockets to listen, in format acceptable by rspamd\n",
                    position: (81, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (83, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "socket",
                         position: (84, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/run/rspamd.sock",
                         position: (84, 21),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "mode",
                         position: (85, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "0666",
                         position: (85, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "owner",
                         position: (86, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "rspamd",
                         position: (86, 20),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (83, 20),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "*:11333",
                      position: (87, 12),
                     },
                    ],
                   },
                  ],
                  position: (83, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (88, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "value",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: Variable {
                    identifier: "map",
                    position: (88, 24),
                   },
                   arguments: [
                    Function {
                     argument: Some(
                      "each",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: IfThenElse {
                      predicate: FunctionApplication {
                       function: Variable {
                        identifier: "isString",
                        position: (88, 39),
                       },
                       arguments: [
                        Variable {
                         identifier: "each",
                         position: (88, 48),
                        },
                       ],
                      },
                      then: IfThenElse {
                       predicate: FunctionApplication {
                        function: Variable {
                         identifier: "isUnixSocket",
                         position: (89, 20),
                        },
                        arguments: [
                         Variable {
                          identifier: "each",
                          position: (89, 33),
                         },
                        ],
                       },
                       then: Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "socket",
                             position: (90, 19),
                            },
                           ],
                          },
                          Variable {
                           identifier: "each",
                           position: (90, 28),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "owner",
                             position: (90, 34),
                            },
                           ],
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (90, 42),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "user",
                              position: (90, 46),
                             },
                            ],
                           },
                           default: None,
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "group",
                             position: (90, 52),
                            },
                           ],
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (90, 60),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "group",
                              position: (90, 64),
                             },
                            ],
                           },
                           default: None,
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "mode",
                             position: (90, 71),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "0644",
                             position: (90, 79),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "rawEntry",
                             position: (90, 86),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Expression {
                             expression: Variable {
                              identifier: "each",
                              position: (90, 100),
                             },
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (90, 18),
                       },
                       else_: Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "socket",
                             position: (91, 19),
                            },
                           ],
                          },
                          Variable {
                           identifier: "each",
                           position: (91, 28),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "rawEntry",
                             position: (91, 34),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Expression {
                             expression: Variable {
                              identifier: "each",
                              position: (91, 48),
                             },
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (91, 18),
                       },
                       position: (89, 16),
                      },
                      else_: Variable {
                       identifier: "each",
                       position: (92, 16),
                      },
                      position: (88, 35),
                     },
                     position: (88, 29),
                    },
                    Variable {
                     identifier: "value",
                     position: (92, 22),
                    },
                   ],
                  },
                  position: (88, 17),
                 },
                ),
               ],
               recursive: false,
               position: (77, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "count",
               position: (94, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (94, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (95, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (95, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (95, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (95, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "int",
                       position: (95, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (96, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (96, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (97, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Number of worker instances to run\n",
                    position: (98, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (94, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "includes",
               position: (101, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (101, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (102, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (102, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (102, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (102, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (102, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (103, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (103, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (104, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of files to include in configuration\n",
                    position: (105, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (101, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (108, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (108, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (109, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (109, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (109, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (110, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (111, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Additional entries to put verbatim into worker section of rspamd config file.",
                    position: (111, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (108, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (51, 15),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (114, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkIf",
           position: (114, 14),
          },
          arguments: [
           BinaryOperation {
            operator: LogicalOr,
            operands: [
             BinaryOperation {
              operator: LogicalOr,
              operands: [
               BinaryOperation {
                operator: LogicalOr,
                operands: [
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "name",
                    position: (114, 20),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "normal",
                      position: (114, 29),
                     },
                    ],
                   },
                  ],
                  position: (114, 25),
                 },
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "name",
                    position: (114, 40),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "controller",
                      position: (114, 49),
                     },
                    ],
                   },
                  ],
                  position: (114, 45),
                 },
                ],
                position: (114, 37),
               },
               BinaryOperation {
                operator: EqualTo,
                operands: [
                 Variable {
                  identifier: "name",
                  position: (114, 64),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "fuzzy",
                    position: (114, 73),
                   },
                  ],
                 },
                ],
                position: (114, 69),
               },
              ],
              position: (114, 61),
             },
             BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "name",
                position: (114, 83),
               },
               String {
                parts: [
                 Raw {
                  content: "rspamd_proxy",
                  position: (114, 92),
                 },
                ],
               },
              ],
              position: (114, 88),
             },
            ],
            position: (114, 80),
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (115, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (115, 14),
               },
               arguments: [
                Variable {
                 identifier: "name",
                 position: (115, 24),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "includes",
                 position: (116, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (116, 18),
               },
               arguments: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "$CONFDIR/worker-",
                     position: (116, 31),
                    },
                    Expression {
                     expression: IfThenElse {
                      predicate: BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        Variable {
                         identifier: "name",
                         position: (116, 52),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "rspamd_proxy",
                           position: (116, 61),
                          },
                         ],
                        },
                       ],
                       position: (116, 57),
                      },
                      then: String {
                       parts: [
                        Raw {
                         content: "proxy",
                         position: (116, 81),
                        },
                       ],
                      },
                      else_: Variable {
                       identifier: "name",
                       position: (116, 93),
                      },
                      position: (116, 49),
                     },
                    },
                    Raw {
                     content: ".inc",
                     position: (116, 98),
                    },
                   ],
                  },
                 ],
                 position: (116, 28),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindSockets",
                 position: (117, 7),
                },
               ],
              },
              LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "unixSocket",
                    position: (119, 11),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "name",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "mode",
                        position: (120, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "0660",
                        position: (120, 21),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "socket",
                        position: (121, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "/run/rspamd/",
                        position: (121, 23),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "name",
                         position: (121, 37),
                        },
                       },
                       Raw {
                        content: ".sock",
                        position: (121, 42),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "owner",
                        position: (122, 13),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (122, 21),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "user",
                         position: (122, 25),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "group",
                        position: (123, 13),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (123, 21),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (123, 25),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (119, 30),
                  },
                  position: (119, 24),
                 },
                ),
               ],
               target: FunctionApplication {
                function: Variable {
                 identifier: "mkDefault",
                 position: (125, 12),
                },
                arguments: [
                 IfThenElse {
                  predicate: BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    Variable {
                     identifier: "name",
                     position: (125, 26),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "normal",
                       position: (125, 35),
                      },
                     ],
                    },
                   ],
                   position: (125, 31),
                  },
                  then: List {
                   elements: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "unixSocket",
                      position: (125, 50),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "rspamd",
                         position: (125, 62),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                   position: (125, 48),
                  },
                  else_: IfThenElse {
                   predicate: BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "name",
                      position: (126, 19),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "controller",
                        position: (126, 28),
                       },
                      ],
                     },
                    ],
                    position: (126, 24),
                   },
                   then: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "localhost:11334",
                        position: (126, 48),
                       },
                      ],
                     },
                    ],
                    position: (126, 45),
                   },
                   else_: IfThenElse {
                    predicate: BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      Variable {
                       identifier: "name",
                       position: (127, 19),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "rspamd_proxy",
                         position: (127, 28),
                        },
                       ],
                      },
                     ],
                     position: (127, 24),
                    },
                    then: List {
                     elements: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "unixSocket",
                        position: (127, 50),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "proxy",
                           position: (127, 62),
                          },
                         ],
                        },
                       ],
                      },
                     ],
                     position: (127, 47),
                    },
                    else_: List {
                     elements: [],
                     position: (128, 16),
                    },
                    position: (127, 16),
                   },
                   position: (126, 16),
                  },
                  position: (125, 23),
                 },
                ],
               },
               position: (118, 9),
              },
             ),
            ],
            recursive: false,
            position: (114, 107),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (50, 40),
      },
      position: (50, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "isUnixSocket",
        position: (132, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "socket",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "hasPrefix",
        position: (132, 26),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "/",
           position: (132, 37),
          },
         ],
        },
        IfThenElse {
         predicate: FunctionApplication {
          function: Variable {
           identifier: "isString",
           position: (132, 45),
          },
          arguments: [
           Variable {
            identifier: "socket",
            position: (132, 54),
           },
          ],
         },
         then: Variable {
          identifier: "socket",
          position: (132, 67),
         },
         else_: PropertyAccess {
          expression: Variable {
           identifier: "socket",
           position: (132, 79),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "socket",
             position: (132, 86),
            },
           ],
          },
          default: None,
         },
         position: (132, 41),
        },
       ],
      },
      position: (132, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkBindSockets",
        position: (134, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "enabled",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "socks",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStringsSep",
         position: (134, 35),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "\n  ",
            position: (134, 53),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "flatten",
           position: (135, 6),
          },
          arguments: [
           FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (135, 15),
            },
            arguments: [
             Function {
              argument: Some(
               "each",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: String {
               parts: [
                Raw {
                 content: "bind_socket = \"",
                 position: (135, 27),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "each",
                   position: (135, 45),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "rawEntry",
                     position: (135, 50),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "\";",
                 position: (135, 59),
                },
               ],
              },
              position: (135, 20),
             },
             Variable {
              identifier: "socks",
              position: (135, 65),
             },
            ],
           },
          ],
         },
        ],
       },
       position: (134, 28),
      },
      position: (134, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "rspamdConfFile",
        position: (137, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (137, 20),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (137, 25),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "rspamd.conf",
          position: (137, 36),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: ".include \"$CONFDIR/common.conf\"\n\noptions {\n  pidfile = \"$RUNDIR/rspamd.pid\";\n  .include \"$CONFDIR/options.inc\"\n  .include(try=true; priority=1,duplicate=merge) \"$LOCAL_CONFDIR/local.d/options.inc\"\n  .include(try=true; priority=10) \"$LOCAL_CONFDIR/override.d/options.inc\"\n}\n\nlogging {\n  type = \"syslog\";\n  .include \"$CONFDIR/logging.inc\"\n  .include(try=true; priority=1,duplicate=merge) \"$LOCAL_CONFDIR/local.d/logging.inc\"\n  .include(try=true; priority=10) \"$LOCAL_CONFDIR/override.d/logging.inc\"\n}\n\n",
          position: (139, 1),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (155, 9),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (155, 27),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (155, 32),
             },
             arguments: [
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "value",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: LetIn {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "includeName",
                      position: (156, 11),
                     },
                    ],
                   },
                   IfThenElse {
                    predicate: BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      Variable {
                       identifier: "name",
                       position: (156, 28),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "rspamd_proxy",
                         position: (156, 37),
                        },
                       ],
                      },
                     ],
                     position: (156, 33),
                    },
                    then: String {
                     parts: [
                      Raw {
                       content: "proxy",
                       position: (156, 57),
                      },
                     ],
                    },
                    else_: Variable {
                     identifier: "name",
                     position: (156, 69),
                    },
                    position: (156, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "tryOverride",
                      position: (157, 11),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "boolToString",
                     position: (157, 25),
                    },
                    arguments: [
                     BinaryOperation {
                      operator: EqualTo,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "value",
                         position: (157, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "extraConfig",
                           position: (157, 45),
                          },
                         ],
                        },
                        default: None,
                       },
                       String {
                        parts: [],
                       },
                      ],
                      position: (157, 57),
                     },
                    ],
                   },
                  ),
                 ],
                 target: String {
                  parts: [
                   Raw {
                    content: "worker \"",
                    position: (159, 1),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "value",
                      position: (159, 19),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "type",
                        position: (159, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" {\n  type = \"",
                    position: (159, 30),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "value",
                      position: (160, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "type",
                        position: (160, 27),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\";\n  ",
                    position: (160, 32),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "optionalString",
                      position: (161, 13),
                     },
                     arguments: [
                      BinaryOperation {
                       operator: NotEqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "value",
                          position: (161, 29),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "enable",
                            position: (161, 35),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "null",
                         position: (161, 45),
                        },
                       ],
                       position: (161, 42),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "enabled = ",
                         position: (162, 14),
                        },
                        Expression {
                         expression: IfThenElse {
                          predicate: BinaryOperation {
                           operator: NotEqualTo,
                           operands: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "value",
                              position: (162, 29),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "enable",
                                position: (162, 35),
                               },
                              ],
                             },
                             default: None,
                            },
                            Variable {
                             identifier: "false",
                             position: (162, 45),
                            },
                           ],
                           position: (162, 42),
                          },
                          then: String {
                           parts: [
                            Raw {
                             content: "yes",
                             position: (162, 57),
                            },
                           ],
                          },
                          else_: String {
                           parts: [
                            Raw {
                             content: "no",
                             position: (162, 68),
                            },
                           ],
                          },
                          position: (162, 26),
                         },
                        },
                        Raw {
                         content: ";",
                         position: (162, 72),
                        },
                       ],
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "\n  ",
                    position: (162, 75),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "mkBindSockets",
                      position: (163, 13),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "value",
                        position: (163, 27),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "enable",
                          position: (163, 33),
                         },
                        ],
                       },
                       default: None,
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "value",
                        position: (163, 40),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bindSockets",
                          position: (163, 46),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "\n  ",
                    position: (163, 58),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "optionalString",
                      position: (164, 13),
                     },
                     arguments: [
                      BinaryOperation {
                       operator: NotEqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "value",
                          position: (164, 29),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "count",
                            position: (164, 35),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "null",
                         position: (164, 44),
                        },
                       ],
                       position: (164, 41),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "count = ",
                         position: (164, 51),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "toString",
                           position: (164, 61),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "value",
                             position: (164, 70),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "count",
                               position: (164, 76),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                        Raw {
                         content: ";",
                         position: (164, 82),
                        },
                       ],
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "\n  ",
                    position: (164, 85),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "concatStringsSep",
                      position: (165, 13),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "\n  ",
                         position: (165, 31),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "map",
                        position: (165, 38),
                       },
                       arguments: [
                        Function {
                         argument: Some(
                          "each",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: String {
                          parts: [
                           Raw {
                            content: ".include \"",
                            position: (165, 50),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "each",
                             position: (165, 63),
                            },
                           },
                           Raw {
                            content: "\"",
                            position: (165, 68),
                           },
                          ],
                         },
                         position: (165, 43),
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "value",
                          position: (165, 73),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "includes",
                            position: (165, 79),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "\n  .include(try=true; priority=1,duplicate=merge) \"$LOCAL_CONFDIR/local.d/worker-",
                    position: (165, 89),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "includeName",
                     position: (166, 91),
                    },
                   },
                   Raw {
                    content: ".inc\"\n  .include(try=",
                    position: (166, 103),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "tryOverride",
                     position: (167, 26),
                    },
                   },
                   Raw {
                    content: "; priority=10) \"$LOCAL_CONFDIR/override.d/worker-",
                    position: (167, 38),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "includeName",
                     position: (167, 89),
                    },
                   },
                   Raw {
                    content: ".inc\"\n}\n",
                    position: (167, 101),
                   },
                  ],
                 },
                 position: (155, 61),
                },
                position: (155, 54),
               },
               position: (155, 48),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (169, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "workers",
                  position: (169, 15),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n\n",
          position: (169, 24),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (171, 9),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (171, 25),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "extraConfig",
                  position: (171, 29),
                 },
                ],
               },
               default: None,
              },
              String {
               parts: [],
              },
             ],
             position: (171, 41),
            },
            String {
             parts: [
              Raw {
               content: ".include(priority=10) \"$LOCAL_CONFDIR/override.d/extra-config.inc\"\n",
               position: (172, 1),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (173, 10),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "filterFiles",
        position: (176, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "files",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "filterAttrs",
        position: (176, 24),
       },
       arguments: [
        Function {
         argument: Some(
          "n",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "v",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: PropertyAccess {
           expression: Variable {
            identifier: "v",
            position: (176, 43),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "enable",
              position: (176, 45),
             },
            ],
           },
           default: None,
          },
          position: (176, 40),
         },
         position: (176, 37),
        },
        Variable {
         identifier: "files",
         position: (176, 53),
        },
       ],
      },
      position: (176, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "rspamdDir",
        position: (177, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (177, 15),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "linkFarm",
          position: (177, 20),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "etc-rspamd-dir",
          position: (177, 30),
         },
        ],
       },
       BinaryOperation {
        operator: Concatenation,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "mapAttrsToList",
           position: (178, 6),
          },
          arguments: [
           Function {
            argument: Some(
             "name",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "file",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "name",
                   position: (178, 36),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "local.d/",
                   position: (178, 44),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (178, 54),
                   },
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (178, 62),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "file",
                  position: (178, 69),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "source",
                    position: (178, 74),
                   },
                  ],
                 },
                 default: None,
                },
               ),
              ],
              recursive: false,
              position: (178, 34),
             },
             position: (178, 28),
            },
            position: (178, 22),
           },
           FunctionApplication {
            function: Variable {
             identifier: "filterFiles",
             position: (178, 86),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (178, 98),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "locals",
                 position: (178, 102),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrsToList",
             position: (179, 6),
            },
            arguments: [
             Function {
              argument: Some(
               "name",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "file",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (179, 36),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "override.d/",
                     position: (179, 44),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "name",
                      position: (179, 57),
                     },
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (179, 65),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "file",
                    position: (179, 72),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "source",
                      position: (179, 77),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                ],
                recursive: false,
                position: (179, 34),
               },
               position: (179, 28),
              },
              position: (179, 22),
             },
             FunctionApplication {
              function: Variable {
               identifier: "filterFiles",
               position: (179, 89),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (179, 101),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "overrides",
                   position: (179, 105),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (180, 6),
              },
              arguments: [
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (180, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "localLuaRules",
                     position: (180, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "null",
                  position: (180, 37),
                 },
                ],
                position: (180, 34),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (180, 45),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "rspamd.local.lua",
                     position: (180, 53),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (180, 72),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (180, 79),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "localLuaRules",
                      position: (180, 83),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                ],
                recursive: false,
                position: (180, 43),
               },
              ],
             },
             List {
              elements: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (181, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "rspamd.conf",
                     position: (181, 17),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (181, 31),
                    },
                   ],
                  },
                  Variable {
                   identifier: "rspamdConfFile",
                   position: (181, 38),
                  },
                 ),
                ],
                recursive: false,
                position: (181, 7),
               },
              ],
              position: (181, 5),
             },
            ],
            position: (180, 101),
           },
          ],
          position: (179, 117),
         },
        ],
        position: (178, 111),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configFileModule",
        position: (184, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "prefix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: None,
       arguments: FunctionArguments {
        arguments: [
         FunctionArgument {
          identifier: "config",
          default: None,
         },
         FunctionArgument {
          identifier: "name",
          default: None,
         },
        ],
        ellipsis: true,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "options",
             position: (185, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "enable",
                position: (186, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (186, 16),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (187, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (187, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bool",
                      position: (187, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (188, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (188, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (189, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Whether this file ",
                     position: (190, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "prefix",
                      position: (190, 31),
                     },
                    },
                    Raw {
                     content: " should be generated.  This\noption allows specific ",
                     position: (190, 38),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "prefix",
                      position: (191, 36),
                     },
                    },
                    Raw {
                     content: " files to be disabled.\n",
                     position: (191, 43),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (186, 25),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "text",
                position: (195, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (195, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (196, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (196, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (197, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (197, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (197, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (197, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "lines",
                        position: (197, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (198, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Text of the file.",
                     position: (198, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (195, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "source",
                position: (201, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (201, 16),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (202, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (202, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "path",
                      position: (202, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (203, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Path of the source file.",
                     position: (203, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (201, 25),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (185, 15),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "config",
             position: (206, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "source",
                position: (207, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkIf",
               position: (207, 16),
              },
              arguments: [
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (207, 22),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "text",
                     position: (207, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "null",
                  position: (207, 37),
                 },
                ],
                position: (207, 34),
               },
               LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "name'",
                     position: (208, 13),
                    },
                   ],
                  },
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    String {
                     parts: [
                      Raw {
                       content: "rspamd-",
                       position: (208, 22),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "prefix",
                        position: (208, 31),
                       },
                      },
                      Raw {
                       content: "-",
                       position: (208, 38),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "baseNameOf",
                      position: (208, 43),
                     },
                     arguments: [
                      Variable {
                       identifier: "name",
                       position: (208, 54),
                      },
                     ],
                    },
                   ],
                   position: (208, 41),
                  },
                 ),
                ],
                target: FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (209, 12),
                 },
                 arguments: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (209, 23),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "writeText",
                       position: (209, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "name'",
                     position: (209, 38),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (209, 44),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "text",
                        position: (209, 51),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ],
                },
                position: (208, 9),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (206, 14),
          },
         ),
        ],
        recursive: false,
        position: (184, 53),
       },
       position: (184, 30),
      },
      position: (184, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configOverrides",
        position: (213, 3),
       },
      ],
     },
     BinaryOperation {
      operator: Update,
      operands: [
       FunctionApplication {
        function: Variable {
         identifier: "mapAttrs'",
         position: (214, 6),
        },
        arguments: [
         Function {
          argument: Some(
           "n",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "v",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "nameValuePair",
             position: (214, 23),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "worker-",
                position: (214, 38),
               },
               Expression {
                expression: IfThenElse {
                 predicate: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "n",
                    position: (214, 50),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "rspamd_proxy",
                      position: (214, 56),
                     },
                    ],
                   },
                  ],
                  position: (214, 52),
                 },
                 then: String {
                  parts: [
                   Raw {
                    content: "proxy",
                    position: (214, 76),
                   },
                  ],
                 },
                 else_: Variable {
                  identifier: "n",
                  position: (214, 88),
                 },
                 position: (214, 47),
                },
               },
               Raw {
                content: ".inc",
                position: (214, 90),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "text",
                   position: (215, 7),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "v",
                  position: (215, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "extraConfig",
                    position: (215, 16),
                   },
                  ],
                 },
                 default: None,
                },
               ),
              ],
              recursive: false,
              position: (214, 96),
             },
            ],
           },
           position: (214, 20),
          },
          position: (214, 17),
         },
         FunctionApplication {
          function: Variable {
           identifier: "filterAttrs",
           position: (217, 6),
          },
          arguments: [
           Function {
            argument: Some(
             "n",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "v",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "v",
                 position: (217, 25),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "extraConfig",
                   position: (217, 27),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [],
               },
              ],
              position: (217, 39),
             },
             position: (217, 22),
            },
            position: (217, 19),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (217, 46),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "workers",
               position: (217, 50),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ],
       },
       IfThenElse {
        predicate: BinaryOperation {
         operator: EqualTo,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (218, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraConfig",
              position: (218, 16),
             },
            ],
           },
           default: None,
          },
          String {
           parts: [],
          },
         ],
         position: (218, 28),
        },
        then: Map {
         bindings: [],
         recursive: false,
         position: (218, 39),
        },
        else_: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Expression {
              expression: String {
               parts: [
                Raw {
                 content: "extra-config.inc",
                 position: (219, 8),
                },
               ],
              },
             },
             Raw {
              content: "text",
              position: (219, 26),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (219, 33),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (219, 37),
              },
             ],
            },
            default: None,
           },
          ),
         ],
         recursive: false,
         position: (218, 47),
        },
        position: (218, 9),
       },
      ],
      position: (218, 5),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (226, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (228, 5),
           },
           Raw {
            content: "rspamd",
            position: (228, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (230, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (230, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "rspamd, the Rapid spam filtering system",
                 position: (230, 32),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "debug",
               position: (232, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (232, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (233, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (233, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (233, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (234, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (234, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (235, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to run the rspamd daemon in debug mode.",
                    position: (235, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (232, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "locals",
               position: (238, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (238, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (239, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (239, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (239, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (239, 37),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "configFileModule",
                        position: (239, 48),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "locals",
                           position: (239, 66),
                          },
                         ],
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                  position: (239, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (240, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (240, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (241, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Local configuration files, written into <filename>/etc/rspamd/local.d/{name}</filename>.\n",
                    position: (242, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (244, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (244, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{ \"redis.conf\".source = \"/nix/store/.../etc/dir/redis.conf\";\n  \"arc.conf\".text = \"allow_envfrom_empty = true;\";\n}\n",
                      position: (245, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (238, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "overrides",
               position: (251, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (251, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (252, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (252, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (252, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (252, 37),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "configFileModule",
                        position: (252, 48),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "overrides",
                           position: (252, 66),
                          },
                         ],
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                  position: (252, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (253, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (253, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (254, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Overridden configuration files, written into <filename>/etc/rspamd/override.d/{name}</filename>.\n",
                    position: (255, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (257, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (257, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{ \"redis.conf\".source = \"/nix/store/.../etc/dir/redis.conf\";\n  \"arc.conf\".text = \"allow_envfrom_empty = true;\";\n}\n",
                      position: (258, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (251, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "localLuaRules",
               position: (264, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (264, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (265, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (265, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (266, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (266, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (266, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (266, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (266, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (267, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Path of file to link to <filename>/etc/rspamd/rspamd.local.lua</filename> for local\nrules written in Lua\n",
                    position: (268, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (264, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "workers",
               position: (273, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (273, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (274, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (274, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (274, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (274, 37),
                     },
                     arguments: [
                      Variable {
                       identifier: "workerOpts",
                       position: (274, 47),
                      },
                     ],
                    },
                   ],
                  },
                  position: (274, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (275, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Attribute set of workers to start.\n",
                    position: (276, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (278, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "normal",
                       position: (279, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [],
                     recursive: false,
                     position: (279, 20),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "controller",
                       position: (280, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [],
                     recursive: false,
                     position: (280, 24),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (278, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (282, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (282, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{\n  normal = {\n    includes = [ \"$CONFDIR/worker-normal.inc\" ];\n    bindSockets = [{\n      socket = \"/run/rspamd/rspamd.sock\";\n      mode = \"0660\";\n      owner = \"",
                      position: (283, 1),
                     },
                     Raw {
                      content: "$",
                      position: (289, 26),
                     },
                     Raw {
                      content: "{config.",
                      position: (289, 29),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (289, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "user",
                          position: (289, 43),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}\";\n      group = \"",
                      position: (289, 48),
                     },
                     Raw {
                      content: "$",
                      position: (290, 26),
                     },
                     Raw {
                      content: "{config.",
                      position: (290, 29),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (290, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "group",
                          position: (290, 43),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}\";\n    }];\n  };\n  controller = {\n    includes = [ \"$CONFDIR/worker-controller.inc\" ];\n    bindSockets = [ \"[::1]:11334\" ];\n  };\n}\n",
                      position: (290, 49),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (273, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (301, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (301, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (302, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (302, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (302, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (303, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (304, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to add at the end of the rspamd configuration\nfile.\n",
                    position: (305, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (301, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (310, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (310, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (311, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (311, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (311, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (312, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "rspamd",
                    position: (312, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (313, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "User to use when no root privileges are required.\n",
                    position: (314, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (310, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (318, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (318, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (319, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (319, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (319, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (320, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "rspamd",
                    position: (320, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (321, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Group to use when no root privileges are required.\n",
                    position: (322, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (318, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "postfix",
               position: (326, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (327, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (327, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (328, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (328, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (328, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (329, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (329, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (330, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Add rspamd milter to postfix main.conf",
                       position: (330, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (327, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "config",
                  position: (333, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (333, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (334, 11),
                      },
                     ],
                    },
                    With {
                     expression: Variable {
                      identifier: "types",
                      position: (334, 23),
                     },
                     target: FunctionApplication {
                      function: Variable {
                       identifier: "attrsOf",
                       position: (334, 30),
                      },
                      arguments: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "oneOf",
                         position: (334, 39),
                        },
                        arguments: [
                         List {
                          elements: [
                           Variable {
                            identifier: "bool",
                            position: (334, 47),
                           },
                           Variable {
                            identifier: "str",
                            position: (334, 52),
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "listOf",
                             position: (334, 57),
                            },
                            arguments: [
                             Variable {
                              identifier: "str",
                              position: (334, 64),
                             },
                            ],
                           },
                          ],
                          position: (334, 45),
                         },
                        ],
                       },
                      ],
                     },
                     position: (334, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (335, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Addon to postfix configuration\n",
                       position: (336, 1),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (338, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "smtpd_milters",
                          position: (339, 13),
                         },
                        ],
                       },
                       List {
                        elements: [
                         String {
                          parts: [
                           Raw {
                            content: "unix:/run/rspamd/rspamd-milter.sock",
                            position: (339, 31),
                           },
                          ],
                         },
                        ],
                        position: (339, 29),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "non_smtpd_milters",
                          position: (340, 13),
                         },
                        ],
                       },
                       List {
                        elements: [
                         String {
                          parts: [
                           Raw {
                            content: "unix:/run/rspamd/rspamd-milter.sock",
                            position: (340, 35),
                           },
                          ],
                         },
                        ],
                        position: (340, 33),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (338, 21),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (333, 27),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (326, 17),
            },
           ),
          ],
          recursive: false,
          position: (228, 23),
         },
        ),
       ],
       recursive: false,
       position: (226, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (350, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (350, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (350, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (350, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (351, 5),
             },
             Raw {
              content: "rspamd",
              position: (351, 14),
             },
             Raw {
              content: "overrides",
              position: (351, 21),
             },
            ],
           },
           Variable {
            identifier: "configOverrides",
            position: (351, 33),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (352, 5),
             },
             Raw {
              content: "rspamd",
              position: (352, 14),
             },
             Raw {
              content: "workers",
              position: (352, 21),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (352, 31),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (352, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "postfix",
                 position: (352, 40),
                },
                Raw {
                 content: "enable",
                 position: (352, 48),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "controller",
                   position: (353, 7),
                  },
                 ],
                },
                Map {
                 bindings: [],
                 recursive: false,
                 position: (353, 20),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "rspamd_proxy",
                   position: (354, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bindSockets",
                      position: (355, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "mode",
                           position: (356, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "0660",
                           position: (356, 19),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "socket",
                           position: (357, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/run/rspamd/rspamd-milter.sock",
                           position: (357, 21),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "owner",
                           position: (358, 11),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (358, 19),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "user",
                            position: (358, 23),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "group",
                           position: (359, 11),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "postfixCfg",
                          position: (359, 19),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "group",
                            position: (359, 30),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                      ],
                      recursive: false,
                      position: (355, 25),
                     },
                    ],
                    position: (355, 23),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "extraConfig",
                      position: (361, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "upstream \"local\" {\n  default = yes; # Self-scan upstreams are always default\n  self_scan = yes; # Enable self-scan\n}\n",
                      position: (362, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (354, 22),
                },
               ),
              ],
              recursive: false,
              position: (352, 55),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (369, 5),
             },
             Raw {
              content: "postfix",
              position: (369, 14),
             },
             Raw {
              content: "config",
              position: (369, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (369, 31),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (369, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "postfix",
                 position: (369, 40),
                },
                Raw {
                 content: "enable",
                 position: (369, 48),
                },
               ],
              },
              default: None,
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (369, 55),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "postfix",
                 position: (369, 59),
                },
                Raw {
                 content: "config",
                 position: (369, 67),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (371, 5),
             },
             Raw {
              content: "services",
              position: (371, 13),
             },
             Raw {
              content: "postfix",
              position: (371, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (371, 32),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (371, 37),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "postfix",
                 position: (371, 41),
                },
                Raw {
                 content: "enable",
                 position: (371, 49),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (372, 7),
                  },
                  Raw {
                   content: "SupplementaryGroups",
                   position: (372, 21),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "postfixCfg",
                    position: (372, 45),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "group",
                      position: (372, 56),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (372, 43),
                },
               ),
              ],
              recursive: false,
              position: (371, 56),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (376, 5),
             },
             Raw {
              content: "systemPackages",
              position: (376, 17),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (376, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "rspamd",
                 position: (376, 41),
                },
               ],
              },
              default: None,
             },
            ],
            position: (376, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (378, 5),
             },
             Raw {
              content: "users",
              position: (378, 11),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (378, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "user",
                  position: (378, 23),
                 },
                ],
               },
               default: None,
              },
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (379, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "rspamd daemon",
                 position: (379, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (380, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (380, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (380, 20),
                 },
                 Raw {
                  content: "uids",
                  position: (380, 24),
                 },
                 Raw {
                  content: "rspamd",
                  position: (380, 29),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (381, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (381, 15),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (381, 19),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (378, 31),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (384, 5),
             },
             Raw {
              content: "groups",
              position: (384, 11),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (384, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (384, 24),
                 },
                ],
               },
               default: None,
              },
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "gid",
                 position: (385, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (385, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (385, 20),
                 },
                 Raw {
                  content: "gids",
                  position: (385, 24),
                 },
                 Raw {
                  content: "rspamd",
                  position: (385, 29),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (384, 33),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (388, 5),
             },
             Raw {
              content: "etc",
              position: (388, 17),
             },
             Raw {
              content: "rspamd",
              position: (388, 21),
             },
             Raw {
              content: "source",
              position: (388, 28),
             },
            ],
           },
           Variable {
            identifier: "rspamdDir",
            position: (388, 37),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (390, 5),
             },
             Raw {
              content: "services",
              position: (390, 13),
             },
             Raw {
              content: "rspamd",
              position: (390, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (391, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Rspamd Service",
                 position: (391, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (393, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (393, 21),
                  },
                 ],
                },
               ],
               position: (393, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (394, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                   position: (394, 18),
                  },
                 ],
                },
               ],
               position: (394, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "restartTriggers",
                 position: (395, 7),
                },
               ],
              },
              List {
               elements: [
                Variable {
                 identifier: "rspamdDir",
                 position: (395, 27),
                },
               ],
               position: (395, 25),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (397, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (398, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (398, 24),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "rspamd",
                        position: (398, 29),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/rspamd ",
                    position: (398, 36),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "optionalString",
                      position: (398, 50),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (398, 65),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "debug",
                          position: (398, 69),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "-d",
                         position: (398, 76),
                        },
                       ],
                      },
                     ],
                    },
                   },
                   Raw {
                    content: " -c /etc/rspamd/rspamd.conf -f",
                    position: (398, 80),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (399, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "always",
                    position: (399, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (401, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (401, 19),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "user",
                        position: (401, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (402, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (402, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "group",
                        position: (402, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SupplementaryGroups",
                    position: (403, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkIf",
                   position: (403, 31),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (403, 36),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "postfix",
                       position: (403, 40),
                      },
                      Raw {
                       content: "enable",
                       position: (403, 48),
                      },
                     ],
                    },
                    default: None,
                   },
                   List {
                    elements: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "postfixCfg",
                       position: (403, 57),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (403, 68),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (403, 55),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RuntimeDirectory",
                    position: (405, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "rspamd",
                    position: (405, 29),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RuntimeDirectoryMode",
                    position: (406, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0755",
                    position: (406, 33),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "StateDirectory",
                    position: (407, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "rspamd",
                    position: (407, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "StateDirectoryMode",
                    position: (408, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0700",
                    position: (408, 31),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "AmbientCapabilities",
                    position: (410, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (410, 31),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "CapabilityBoundingSet",
                    position: (411, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "DevicePolicy",
                    position: (412, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "closed",
                    position: (412, 25),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "LockPersonality",
                    position: (413, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (413, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "NoNewPrivileges",
                    position: (414, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (414, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateDevices",
                    position: (415, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (415, 26),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateMounts",
                    position: (416, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (416, 25),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateTmp",
                    position: (417, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (417, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateUsers",
                    position: (419, 9),
                   },
                  ],
                 },
                 UnaryOperation {
                  operator: Not,
                  operand: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (419, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "postfix",
                      position: (419, 29),
                     },
                     Raw {
                      content: "enable",
                      position: (419, 37),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (419, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectClock",
                    position: (420, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (420, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectControlGroups",
                    position: (421, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (421, 32),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectHome",
                    position: (422, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (422, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectHostname",
                    position: (423, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (423, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelLogs",
                    position: (424, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (424, 29),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelModules",
                    position: (425, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (425, 32),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelTunables",
                    position: (426, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (426, 33),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectSystem",
                    position: (427, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "strict",
                    position: (427, 26),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RemoveIPC",
                    position: (428, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (428, 21),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictAddressFamilies",
                    position: (429, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "AF_INET",
                      position: (429, 38),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "AF_INET6",
                      position: (429, 48),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "AF_UNIX",
                      position: (429, 59),
                     },
                    ],
                   },
                  ],
                  position: (429, 35),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictNamespaces",
                    position: (430, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (430, 30),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictRealtime",
                    position: (431, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (431, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictSUIDSGID",
                    position: (432, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (432, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SystemCallArchitectures",
                    position: (433, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "native",
                    position: (433, 36),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SystemCallFilter",
                    position: (434, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "@system-service",
                    position: (434, 29),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "UMask",
                    position: (435, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0077",
                    position: (435, 18),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (397, 23),
              },
             ),
            ],
            recursive: false,
            position: (390, 31),
           },
          ),
         ],
         recursive: false,
         position: (350, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (439, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (440, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (440, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "rspamd",
               position: (440, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "socketActivation",
               position: (440, 51),
              },
             ],
            },
           ],
           position: (440, 28),
          },
          String {
           parts: [
            Raw {
             content: "Socket activation never worked correctly and could at this time not be fixed and so was removed",
             position: (441, 9),
            },
           ],
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (442, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (442, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "rspamd",
               position: (442, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "bindSocket",
               position: (442, 51),
              },
             ],
            },
           ],
           position: (442, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (442, 68),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "rspamd",
               position: (442, 79),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "workers",
               position: (442, 88),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "normal",
               position: (442, 98),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "bindSockets",
               position: (442, 107),
              },
             ],
            },
           ],
           position: (442, 65),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (443, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (443, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "rspamd",
               position: (443, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "bindUISocket",
               position: (443, 51),
              },
             ],
            },
           ],
           position: (443, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (443, 70),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "rspamd",
               position: (443, 81),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "workers",
               position: (443, 90),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "controller",
               position: (443, 100),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "bindSockets",
               position: (443, 113),
              },
             ],
            },
           ],
           position: (443, 67),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (444, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (444, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "rmilter",
               position: (444, 42),
              },
             ],
            },
           ],
           position: (444, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use services.rspamd.* instead to set up milter service",
             position: (444, 54),
            },
           ],
          },
         ],
        },
       ],
       position: (439, 13),
      },
     ),
    ],
    recursive: false,
    position: (223, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}