docs: def wait_script(name,
                  source=None,
                  template=None,
                  onlyif=None,
                  unless=None,
                  cwd=None,
                  runas=None,
                  shell=None,
                  env=None,
                  stateful=False,
                  umask=None,
                  use_vt=False,
                  output_loglevel='debug',
                  hide_output=False,
                  success_retcodes=None,
                  success_stdout=None,
                  success_stderr=None,
                  **kwargs):
      '''
      Download a script from a remote source and execute it only if a watch
      statement calls it.
  
      source
          The source script being downloaded to the minion, this source script is
          hosted on the salt master server.  If the file is located on the master
          in the directory named spam, and is called eggs, the source string is
          salt://spam/eggs
  
      template
          If this setting is applied then the named templating engine will be
          used to render the downloaded file, currently jinja, mako, and wempy
          are supported
  
      name
          The command to execute, remember that the command will execute with the
          path and permissions of the salt-minion.
  
      onlyif
          A command to run as a check, run the named command only if the command
          passed to the ``onlyif`` option returns true
  
      unless
          A command to run as a check, only run the named command if the command
          passed to the ``unless`` option returns false
  
      cwd
          The current working directory to execute the command in, defaults to
          /root
  
      runas
          The user name to run the command as
  
      shell
          The shell to use for execution, defaults to the shell grain
  
      env
          A list of environment variables to be set prior to execution.
          Example:
  
          .. code-block:: yaml
  
              salt://scripts/foo.sh:
                cmd.wait_script:
                  - env:
                    - BATCH: 'yes'
  
          .. warning::
  
              The above illustrates a common PyYAML pitfall, that **yes**,
              **no**, **on**, **off**, **true**, and **false** are all loaded as
              boolean ``True`` and ``False`` values, and must be enclosed in
              quotes to be used as strings. More info on this (and other) PyYAML
              idiosyncrasies can be found :ref:`here <yaml-idiosyncrasies>`.
  
          Variables as values are not evaluated. So $PATH in the following
          example is a literal '$PATH':
  
          .. code-block:: yaml
  
              salt://scripts/bar.sh:
                cmd.wait_script:
                  - env: "PATH=/some/path:$PATH"
  
          One can still use the existing $PATH by using a bit of Jinja:
  
          .. code-block:: jinja
  
              {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
  
              mycommand:
                cmd.run:
                  - name: ls -l /
                  - env:
                    - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
  
      umask
           The umask (in octal) to use when running the command.
  
      stateful
          The command being executed is expected to return data about executing
          a state. For more information, see the :ref:`stateful-argument` section.
  
      use_vt
          Use VT utils (saltstack) to stream the command output more
          interactively to the console and the logs.
          This is experimental.
  
      output_loglevel : debug
          Control the loglevel at which the output from the command is logged to
          the minion log.
  
          .. note::
              The command being run will still be logged at the ``debug``
              loglevel regardless, unless ``quiet`` is used for this value.
  
      hide_output : False
          Suppress stdout and stderr in the state's results.
  
          .. note::
              This is separate from ``output_loglevel``, which only handles how
              Salt logs to the minion log.
  
          .. versionadded:: 2018.3.0
  
      success_retcodes: This parameter will be allow a list of
          non-zero return codes that should be considered a success.  If the
          return code returned from the run matches any in the provided list,
          the return code will be overridden with zero.
  
        .. versionadded:: 2019.2.0
  
      success_stdout: This parameter will be allow a list of
          strings that when found in standard out should be considered a success.
          If stdout returned from the run matches any in the provided list,
          the return code will be overridden with zero.
  
        .. versionadded:: Neon
  
      success_stderr: This parameter will be allow a list of
          strings that when found in standard error should be considered a success.
          If stderr returned from the run matches any in the provided list,
          the return code will be overridden with zero.
  
        .. versionadded:: Neon
      '''
      # Ignoring our arguments is intentional.
      return {'name': name,
              'changes': {},
              'result': True,
              'comment': ''}