docs: def solve(
      solver, mzn, *dzn_files, data=None, include=None, stdlib_dir=None,
      globals_dir=None, allow_multiple_assignments=False, output_mode='item',
      timeout=None, two_pass=None, pre_passes=None, output_objective=False,
      non_unique=False, all_solutions=False, num_solutions=None,
      free_search=False, parallel=None, seed=None, **kwargs
  ):
      """Flatten and solve a MiniZinc program.
  
      Parameters
      ----------
      solver : Solver
          The ``Solver`` instance to use.
      mzn : str
          The path to the minizinc model file.
      *dzn_files
          A list of paths to dzn files to attach to the minizinc execution,
          provided as positional arguments; by default no data file is attached.
      data : list of str
          Additional data as a list of strings containing dzn variables
          assignments.
      include : str or list
          One or more additional paths to search for included ``.mzn`` files.
      stdlib_dir : str
          The path to the MiniZinc standard library. Provide it only if it is
          different from the default one.
      globals_dir : str
          The path to the MiniZinc globals directory. Provide it only if it is
          different from the default one.
      allow_multiple_assignments : bool
          Whether to allow multiple assignments of variables. Sometimes is
          convenient to simply let the data file override the value already
          assigned in the minizinc file. Default is ``False``.
      output_mode : {'item', 'dzn', 'json'}
          The desired output format. The default is ``'item'`` which outputs a
          stream of strings as returned by the ``solns2out`` tool, formatted
          according to the output statement of the MiniZinc model. The ``'dzn'``
          and ``'json'`` formats output a stream of strings formatted in dzn and
          json respectively.
      timeout : int
          The timeout in seconds for the flattening + solving process.
      two_pass : bool or int
          If ``two_pass`` is True, then it is equivalent to the ``--two-pass``
          option for the ``minizinc`` executable. If ``two_pass`` is an integer
          ``<n>``, instead, it is equivalent to the ``-O<n>`` option for the
          ``minizinc`` executable.
      pre_passes : int
          Equivalent to the ``--pre-passes`` option for the ``minizinc``
          executable.
      output_objective : bool
          Equivalent to the ``--output-objective`` option for the ``minizinc``
          executable. Adds a field ``_objective`` to all solutions.
      non_unique : bool
          Equivalent to the ``--non-unique`` option for the ``minizinc``
          executable.
      all_solutions : bool
          Whether all the solutions must be returned. This option might not work
          if the solver does not support it. Default is ``False``.
      num_solutions : int
          The upper bound on the number of solutions to be returned. This option
          might not work if the solver does not support it. Default is ``1``.
      free_search : bool
          If True, instruct the solver to perform free search.
      parallel : int
          The number of parallel threads the solver can utilize for the solving.
      seed : int
          The random number generator seed to pass to the solver.
      **kwargs
          Additional arguments to pass to the solver, provided as additional
          keyword arguments to this function. Check the solver documentation for
          the available arguments.
  
      Returns
      -------
          Object wrapping the executed process.
      """
  
      args = _solve_args(
          solver, timeout=timeout, two_pass=two_pass, pre_passes=pre_passes,
          output_objective=output_objective, non_unique=non_unique,
          all_solutions=all_solutions, num_solutions=num_solutions,
          free_search=free_search, parallel=parallel, seed=seed, **kwargs
      )
  
      args += _flattening_args(
          mzn, *dzn_files, data=data, stdlib_dir=stdlib_dir,
          globals_dir=globals_dir, output_mode=output_mode, include=include,
          allow_multiple_assignments=allow_multiple_assignments
      )
  
      input = mzn if args[-1] == '-' else None
  
      t0 = _time()
  
      try:
          proc = _run_minizinc_proc(*args, input=input)
      except RuntimeError as err:
          raise MiniZincError(mzn_file, args) from err
  
      solve_time = _time() - t0
      logger.info('Solving completed in {:>3.2f} sec'.format(solve_time))
  
      return proc