docs: def interp(self, coords=None, method='linear', assume_sorted=False,
                 kwargs={}, **coords_kwargs):
          """ Multidimensional interpolation of Dataset.
  
          Parameters
          ----------
          coords : dict, optional
              Mapping from dimension names to the new coordinates.
              New coordinate can be a scalar, array-like or DataArray.
              If DataArrays are passed as new coordates, their dimensions are
              used for the broadcasting.
          method: string, optional.
              {'linear', 'nearest'} for multidimensional array,
              {'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic'}
              for 1-dimensional array. 'linear' is used by default.
          assume_sorted: boolean, optional
              If False, values of coordinates that are interpolated over can be
              in any order and they are sorted first. If True, interpolated
              coordinates are assumed to be an array of monotonically increasing
              values.
          kwargs: dictionary, optional
              Additional keyword passed to scipy's interpolator.
          **coords_kwarg : {dim: coordinate, ...}, optional
              The keyword arguments form of ``coords``.
              One of coords or coords_kwargs must be provided.
  
          Returns
          -------
          interpolated: xr.Dataset
              New dataset on the new coordinates.
  
          Notes
          -----
          scipy is required.
  
          See Also
          --------
          scipy.interpolate.interp1d
          scipy.interpolate.interpn
          """
          from . import missing
  
          coords = either_dict_or_kwargs(coords, coords_kwargs, 'interp')
          indexers = OrderedDict(self._validate_indexers(coords))
  
          obj = self if assume_sorted else self.sortby([k for k in coords])
  
          def maybe_variable(obj, k):
              # workaround to get variable for dimension without coordinate.
              try:
                  return obj._variables[k]
              except KeyError:
                  return as_variable((k, range(obj.dims[k])))
  
          def _validate_interp_indexer(x, new_x):
              # In the case of datetimes, the restrictions placed on indexers
              # used with interp are stronger than those which are placed on
              # isel, so we need an additional check after _validate_indexers.
              if (_contains_datetime_like_objects(x) and
                      not _contains_datetime_like_objects(new_x)):
                  raise TypeError('When interpolating over a datetime-like '
                                  'coordinate, the coordinates to '
                                  'interpolate to must be either datetime '
                                  'strings or datetimes. '
                                  'Instead got\n{}'.format(new_x))
              else:
                  return (x, new_x)
  
          variables = OrderedDict()
          for name, var in obj._variables.items():
              if name not in indexers:
                  if var.dtype.kind in 'uifc':
                      var_indexers = {
                          k: _validate_interp_indexer(maybe_variable(obj, k), v)
                          for k, v in indexers.items()
                          if k in var.dims
                      }
                      variables[name] = missing.interp(
                          var, var_indexers, method, **kwargs)
                  elif all(d not in indexers for d in var.dims):
                      # keep unrelated object array
                      variables[name] = var
  
          coord_names = set(variables).intersection(obj._coord_names)
          indexes = OrderedDict(
              (k, v) for k, v in obj.indexes.items() if k not in indexers)
          selected = self._replace_with_new_dims(
              variables.copy(), coord_names, indexes=indexes)
  
          # attach indexer as coordinate
          variables.update(indexers)
          indexes.update(
              (k, v.to_index()) for k, v in indexers.items() if v.dims == (k,)
          )
  
          # Extract coordinates from indexers
          coord_vars, new_indexes = (
              selected._get_indexers_coords_and_indexes(coords))
          variables.update(coord_vars)
          indexes.update(new_indexes)
  
          coord_names = (set(variables)
                         .intersection(obj._coord_names)
                         .union(coord_vars))
          return self._replace_with_new_dims(
              variables, coord_names, indexes=indexes)