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