---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (5, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfge",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (9, 10),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "environment",
         position: (9, 17),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (11, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (11, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "programs",
         position: (11, 16),
        },
        Raw {
         content: "zsh",
         position: (11, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "opt",
        position: (12, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (12, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "programs",
         position: (12, 17),
        },
        Raw {
         content: "zsh",
         position: (12, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "zshAliases",
        position: (14, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "concatStringsSep",
       position: (14, 16),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "\n",
          position: (14, 34),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mapAttrsFlatten",
         position: (15, 5),
        },
        arguments: [
         Function {
          argument: Some(
           "k",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "v",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: String {
            parts: [
             Raw {
              content: "alias ",
              position: (15, 29),
             },
             Expression {
              expression: Variable {
               identifier: "k",
               position: (15, 37),
              },
             },
             Raw {
              content: "=",
              position: (15, 39),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "escapeShellArg",
                position: (15, 42),
               },
               arguments: [
                Variable {
                 identifier: "v",
                 position: (15, 57),
                },
               ],
              },
             },
            ],
           },
           position: (15, 25),
          },
          position: (15, 22),
         },
         FunctionApplication {
          function: Variable {
           identifier: "filterAttrs",
           position: (16, 8),
          },
          arguments: [
           Function {
            argument: Some(
             "k",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "v",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               Variable {
                identifier: "v",
                position: (16, 27),
               },
               Variable {
                identifier: "null",
                position: (16, 32),
               },
              ],
              position: (16, 29),
             },
             position: (16, 24),
            },
            position: (16, 21),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (16, 38),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "shellAliases",
               position: (16, 42),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "zshStartupNotes",
        position: (19, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "# Note that generated /etc/zprofile and /etc/zshrc files do a lot of\n# non-standard setup to make zsh usable with no configuration by default.\n#\n# Which means that unless you explicitly meticulously override everything\n# generated, interactions between your ~/.zshrc and these files are likely\n# to be rather surprising.\n#\n# Note however, that you can disable loading of the generated /etc/zprofile\n# and /etc/zshrc (you can't disable loading of /etc/zshenv, but it is\n# designed to not set anything surprising) by setting `no_global_rcs` option\n# in ~/.zshenv:\n#\n#   echo setopt no_global_rcs >> ~/.zshenv\n#\n# See \"STARTUP/SHUTDOWN FILES\" section of zsh(1) for more info.\n",
        position: (20, 1),
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (41, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "programs",
            position: (43, 5),
           },
           Raw {
            content: "zsh",
            position: (43, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (45, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (45, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (46, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (46, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (47, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to configure zsh as an interactive shell. To enable zsh for\na particular user, use the <option>users.users.&lt;name?&gt;.shell</option>\noption for that user. To enable zsh system-wide use the\n<option>users.defaultUserShell</option> option.\n",
                    position: (48, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (53, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (53, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (53, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (45, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "shellAliases",
               position: (56, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (56, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (57, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (57, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (58, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Set of aliases for zsh shell, which overrides <option>environment.shellAliases</option>.\nSee <option>environment.shellAliases</option> for an option format description.\n",
                    position: (59, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (62, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (62, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (62, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "nullOr",
                      position: (62, 37),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "either",
                        position: (62, 45),
                       },
                       arguments: [
                        Variable {
                         identifier: "str",
                         position: (62, 52),
                        },
                        Variable {
                         identifier: "path",
                         position: (62, 56),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                  position: (62, 16),
                 },
                ),
               ],
               recursive: false,
               position: (56, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "shellInit",
               position: (65, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (65, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (66, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (67, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code called during zsh shell initialisation.\n",
                    position: (68, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (70, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (70, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (70, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (65, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "loginShellInit",
               position: (73, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (73, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (74, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (75, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code called during zsh login shell initialisation.\n",
                    position: (76, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (78, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (78, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (78, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (73, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "interactiveShellInit",
               position: (81, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (81, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (82, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (83, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code called during interactive zsh shell initialisation.\n",
                    position: (84, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (86, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (86, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (86, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (81, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "promptInit",
               position: (89, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (89, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (90, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "# Note that to manually override this in ~/.zshrc you should run `prompt off`\n# before setting your PS1 and etc. Otherwise this will likely to interact with\n# your ~/.zshrc configuration in unexpected ways as the default prompt sets\n# a lot of different prompt variables.\nautoload -U promptinit && promptinit && prompt suse && setopt prompt_sp\n",
                    position: (91, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (97, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell script code used to initialise the zsh prompt.\n",
                    position: (98, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (100, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (100, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (100, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (89, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "histSize",
               position: (103, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (103, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (104, 9),
                   },
                  ],
                 },
                 Int {
                  value: 2000,
                  position: (104, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (105, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Change history size.\n",
                    position: (106, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (108, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (108, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (108, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (103, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "histFile",
               position: (111, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (111, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (112, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "$HOME/.zsh_history",
                    position: (112, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (113, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Change history file.\n",
                    position: (114, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (116, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (116, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (116, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (111, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "setOptions",
               position: (119, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (119, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (120, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (120, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (120, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (120, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (120, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (121, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "HIST_IGNORE_DUPS",
                      position: (122, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "SHARE_HISTORY",
                      position: (123, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "HIST_FCNTL_LOCK",
                      position: (124, 12),
                     },
                    ],
                   },
                  ],
                  position: (121, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (126, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "EXTENDED_HISTORY",
                      position: (126, 22),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "RM_STAR_WAIT",
                      position: (126, 41),
                     },
                    ],
                   },
                  ],
                  position: (126, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (127, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Configure zsh options. See\n<citerefentry><refentrytitle>zshoptions</refentrytitle><manvolnum>1</manvolnum></citerefentry>.\n",
                    position: (128, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (119, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableCompletion",
               position: (133, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (133, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (134, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (134, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (135, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable zsh completion for all interactive zsh shells.\n",
                    position: (136, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (138, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (138, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (138, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (133, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableBashCompletion",
               position: (141, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (141, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (142, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (142, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (143, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable compatibility with bash's programmable completion system.\n",
                    position: (144, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (146, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (146, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (146, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (141, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableGlobalCompInit",
               position: (149, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (149, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (150, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (150, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "enableCompletion",
                     position: (150, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (151, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (151, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "config.",
                      position: (151, 42),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (151, 51),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "enableCompletion",
                          position: (151, 55),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (152, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable execution of compinit call for all interactive zsh shells.\n\nThis option can be disabled if the user wants to extend its\n<literal>fpath</literal> and a custom <literal>compinit</literal>\ncall in the local config is required.\n",
                    position: (153, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (159, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (159, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (159, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (149, 39),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (43, 20),
         },
        ),
       ],
       recursive: false,
       position: (41, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (166, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (166, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (166, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (166, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "programs",
              position: (168, 5),
             },
             Raw {
              content: "zsh",
              position: (168, 14),
             },
             Raw {
              content: "shellAliases",
              position: (168, 18),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (168, 33),
            },
            arguments: [
             Function {
              argument: Some(
               "name",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Variable {
               identifier: "mkDefault",
               position: (168, 49),
              },
              position: (168, 43),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfge",
               position: (168, 60),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "shellAliases",
                 position: (168, 65),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (170, 5),
             },
             Raw {
              content: "etc",
              position: (170, 17),
             },
             Raw {
              content: "zshenv",
              position: (170, 21),
             },
             Raw {
              content: "text",
              position: (170, 28),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "# /etc/zshenv: DO NOT EDIT -- this file has been generated automatically.\n# This file is read for all shells.\n\n# Only execute this file once per shell.\nif [ -n \"$__ETC_ZSHENV_SOURCED\" ]; then return; fi\n__ETC_ZSHENV_SOURCED=1\n\nif [ -z \"$__NIXOS_SET_ENVIRONMENT_DONE\" ]; then\n    . ",
              position: (172, 1),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (180, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "system",
                  position: (180, 24),
                 },
                 Raw {
                  content: "build",
                  position: (180, 31),
                 },
                 Raw {
                  content: "setEnvironment",
                  position: (180, 37),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\nfi\n\nHELPDIR=\"",
              position: (180, 52),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (183, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "zsh",
                  position: (183, 25),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "/share/zsh/$ZSH_VERSION/help\"\n\n# Tell zsh how to find installed completions.\nfor p in ",
              position: (183, 29),
             },
             Raw {
              content: "$",
              position: (186, 18),
             },
             Raw {
              content: "{(z)NIX_PROFILES}; do\n    fpath+=($p/share/zsh/site-functions $p/share/zsh/$ZSH_VERSION/functions $p/share/zsh/vendor-completions)\ndone\n\n# Setup custom shell init stuff.\n",
              position: (186, 21),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfge",
                position: (191, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "shellInit",
                  position: (191, 16),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\n\n",
              position: (191, 26),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (193, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "shellInit",
                  position: (193, 15),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\n\n# Read system-wide modifications.\nif test -f /etc/zshenv.local; then\n    . /etc/zshenv.local\nfi\n",
              position: (193, 25),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (201, 5),
             },
             Raw {
              content: "etc",
              position: (201, 17),
             },
             Raw {
              content: "zprofile",
              position: (201, 21),
             },
             Raw {
              content: "text",
              position: (201, 30),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "# /etc/zprofile: DO NOT EDIT -- this file has been generated automatically.\n# This file is read for login shells.\n#\n",
              position: (203, 1),
             },
             Expression {
              expression: Variable {
               identifier: "zshStartupNotes",
               position: (206, 11),
              },
             },
             Raw {
              content: "\n\n# Only execute this file once per shell.\nif [ -n \"$__ETC_ZPROFILE_SOURCED\" ]; then return; fi\n__ETC_ZPROFILE_SOURCED=1\n\n# Setup custom login shell init stuff.\n",
              position: (206, 27),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfge",
                position: (213, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "loginShellInit",
                  position: (213, 16),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\n\n",
              position: (213, 31),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (215, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "loginShellInit",
                  position: (215, 15),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\n\n# Read system-wide modifications.\nif test -f /etc/zprofile.local; then\n    . /etc/zprofile.local\nfi\n",
              position: (215, 30),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (223, 5),
             },
             Raw {
              content: "etc",
              position: (223, 17),
             },
             Raw {
              content: "zshrc",
              position: (223, 21),
             },
             Raw {
              content: "text",
              position: (223, 27),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "# /etc/zshrc: DO NOT EDIT -- this file has been generated automatically.\n# This file is read for interactive shells.\n#\n",
              position: (225, 1),
             },
             Expression {
              expression: Variable {
               identifier: "zshStartupNotes",
               position: (228, 11),
              },
             },
             Raw {
              content: "\n\n# Only execute this file once per shell.\nif [ -n \"$__ETC_ZSHRC_SOURCED\" -o -n \"$NOSYSZSHRC\" ]; then return; fi\n__ETC_ZSHRC_SOURCED=1\n\n",
              position: (228, 27),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "optionalString",
                position: (234, 11),
               },
               arguments: [
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (234, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "setOptions",
                      position: (234, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                  List {
                   elements: [],
                   position: (234, 45),
                  },
                 ],
                 position: (234, 42),
                },
                String {
                 parts: [
                  Raw {
                   content: "# Set zsh options.\nsetopt ",
                   position: (235, 1),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "concatStringsSep",
                     position: (236, 20),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: " ",
                        position: (236, 38),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (236, 41),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "setOptions",
                         position: (236, 45),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "\n",
                   position: (236, 56),
                  },
                 ],
                },
               ],
              },
             },
             Raw {
              content: "\n\n# Setup command line history.\n# Don't export these, otherwise other shells (bash) will try to use same HISTFILE.\nSAVEHIST=",
              position: (237, 12),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (241, 20),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (241, 29),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "histSize",
                    position: (241, 33),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             },
             Raw {
              content: "\nHISTSIZE=",
              position: (241, 42),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (242, 20),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (242, 29),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "histSize",
                    position: (242, 33),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             },
             Raw {
              content: "\nHISTFILE=",
              position: (242, 42),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (243, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "histFile",
                  position: (243, 24),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\n\n# Configure sane keyboard defaults.\n. /etc/zinputrc\n\n",
              position: (243, 33),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "optionalString",
                position: (248, 11),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (248, 26),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "enableGlobalCompInit",
                    position: (248, 30),
                   },
                  ],
                 },
                 default: None,
                },
                String {
                 parts: [
                  Raw {
                   content: "# Enable autocompletion.\nautoload -U compinit && compinit\n",
                   position: (249, 1),
                  },
                 ],
                },
               ],
              },
             },
             Raw {
              content: "\n\n",
              position: (251, 12),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "optionalString",
                position: (253, 11),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (253, 26),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "enableBashCompletion",
                    position: (253, 30),
                   },
                  ],
                 },
                 default: None,
                },
                String {
                 parts: [
                  Raw {
                   content: "# Enable compatibility with bash's completion system.\nautoload -U bashcompinit && bashcompinit\n",
                   position: (254, 1),
                  },
                 ],
                },
               ],
              },
             },
             Raw {
              content: "\n\n# Setup custom interactive shell init stuff.\n",
              position: (256, 12),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfge",
                position: (259, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "interactiveShellInit",
                  position: (259, 16),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\n\n",
              position: (259, 37),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (261, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "interactiveShellInit",
                  position: (261, 15),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\n\n# Setup aliases.\n",
              position: (261, 36),
             },
             Expression {
              expression: Variable {
               identifier: "zshAliases",
               position: (264, 11),
              },
             },
             Raw {
              content: "\n\n# Setup prompt.\n",
              position: (264, 22),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (267, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "promptInit",
                  position: (267, 15),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "\n\n# Disable some features to support TRAMP.\nif [ \"$TERM\" = dumb ]; then\n    unsetopt zle prompt_cr prompt_subst\n    unset RPS1 RPROMPT\n    PS1=",
              position: (267, 26),
             },
             Raw {
              content: "'",
              position: (273, 17),
             },
             Raw {
              content: "$ '\n    PROMPT=",
              position: (273, 18),
             },
             Raw {
              content: "'",
              position: (274, 20),
             },
             Raw {
              content: "$ '\nfi\n\n# Read system-wide modifications.\nif test -f /etc/zshrc.local; then\n    . /etc/zshrc.local\nfi\n",
              position: (274, 21),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (286, 5),
             },
             Raw {
              content: "etc",
              position: (286, 17),
             },
             Raw {
              content: "zinputrc",
              position: (286, 21),
             },
             Raw {
              content: "text",
              position: (286, 30),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (286, 37),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "readFile",
                position: (286, 46),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./zinputrc",
                position: (286, 55),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (288, 5),
             },
             Raw {
              content: "systemPackages",
              position: (288, 17),
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             List {
              elements: [
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (288, 36),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "zsh",
                   position: (288, 41),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (288, 34),
             },
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (289, 10),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (289, 19),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "enableCompletion",
                   position: (289, 23),
                  },
                 ],
                },
                default: None,
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (289, 40),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "nix-zsh-completions",
                   position: (289, 45),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ],
            position: (289, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (291, 5),
             },
             Raw {
              content: "pathsToLink",
              position: (291, 17),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (291, 31),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (291, 40),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "enableCompletion",
                 position: (291, 44),
                },
               ],
              },
              default: None,
             },
             String {
              parts: [
               Raw {
                content: "/share/zsh",
                position: (291, 62),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (295, 5),
             },
             Raw {
              content: "shells",
              position: (295, 17),
             },
            ],
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "/run/current-system/sw/bin/zsh",
                position: (297, 10),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (298, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "zsh",
                    position: (298, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/bin/zsh",
                position: (298, 21),
               },
              ],
             },
            ],
            position: (296, 7),
           },
          ),
         ],
         recursive: false,
         position: (166, 28),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (39, 1),
   },
   position: (7, 1),
  },
  position: (5, 1),
 },
 position: (3, 1),
}