docs: def reindex_variables(
      variables: Mapping[Any, Variable],
      sizes: Mapping[Any, int],
      indexes: Mapping[Any, pd.Index],
      indexers: Mapping,
      method: Optional[str] = None,
      tolerance: Any = None,
      copy: bool = True,
  ) -> 'Tuple[OrderedDict[Any, Variable], OrderedDict[Any, pd.Index]]':
      """Conform a dictionary of aligned variables onto a new set of variables,
      filling in missing values with NaN.
  
      Not public API.
  
      Parameters
      ----------
      variables : dict-like
          Dictionary of xarray.Variable objects.
      sizes : dict-like
          Dictionary from dimension names to integer sizes.
      indexes : dict-like
          Dictionary of indexes associated with variables.
      indexers : dict
          Dictionary with keys given by dimension names and values given by
          arrays of coordinates tick labels. Any mis-matched coordinate values
          will be filled in with NaN, and any mis-matched dimension names will
          simply be ignored.
      method : {None, 'nearest', 'pad'/'ffill', 'backfill'/'bfill'}, optional
          Method to use for filling index values in ``indexers`` not found in
          this dataset:
            * None (default): don't fill gaps
            * pad / ffill: propagate last valid index value forward
            * backfill / bfill: propagate next valid index value backward
            * nearest: use nearest valid index value
      tolerance : optional
          Maximum distance between original and new labels for inexact matches.
          The values of the index at the matching locations must satisfy the
          equation ``abs(index[indexer] - target) <= tolerance``.
      copy : bool, optional
          If ``copy=True``, data in the return values is always copied. If
          ``copy=False`` and reindexing is unnecessary, or can be performed
          with only slice operations, then the output may share memory with
          the input. In either case, new xarray objects are always returned.
  
      Returns
      -------
      reindexed : OrderedDict
          Dict of reindexed variables.
      new_indexes : OrderedDict
          Dict of indexes associated with the reindexed variables.
      """
      from .dataarray import DataArray
  
      # create variables for the new dataset
      reindexed = OrderedDict()  # type: OrderedDict[Any, Variable]
  
      # build up indexers for assignment along each dimension
      int_indexers = {}
      new_indexes = OrderedDict(indexes)
      masked_dims = set()
      unchanged_dims = set()
  
      for dim, indexer in indexers.items():
          if isinstance(indexer, DataArray) and indexer.dims != (dim,):
              warnings.warn(
                  "Indexer has dimensions {0:s} that are different "
                  "from that to be indexed along {1:s}. "
                  "This will behave differently in the future.".format(
                      str(indexer.dims), dim),
                  FutureWarning, stacklevel=3)
  
          target = new_indexes[dim] = utils.safe_cast_to_index(indexers[dim])
  
          if dim in indexes:
              index = indexes[dim]
  
              if not index.is_unique:
                  raise ValueError(
                      'cannot reindex or align along dimension %r because the '
                      'index has duplicate values' % dim)
  
              int_indexer = get_indexer_nd(index, target, method, tolerance)
  
              # We uses negative values from get_indexer_nd to signify
              # values that are missing in the index.
              if (int_indexer < 0).any():
                  masked_dims.add(dim)
              elif np.array_equal(int_indexer, np.arange(len(index))):
                  unchanged_dims.add(dim)
  
              int_indexers[dim] = int_indexer
  
          if dim in variables:
              var = variables[dim]
              args = (var.attrs, var.encoding)  # type: tuple
          else:
              args = ()
          reindexed[dim] = IndexVariable((dim,), target, *args)
  
      for dim in sizes:
          if dim not in indexes and dim in indexers:
              existing_size = sizes[dim]
              new_size = indexers[dim].size
              if existing_size != new_size:
                  raise ValueError(
                      'cannot reindex or align along dimension %r without an '
                      'index because its size %r is different from the size of '
                      'the new index %r' % (dim, existing_size, new_size))
  
      for name, var in variables.items():
          if name not in indexers:
              key = tuple(slice(None)
                          if d in unchanged_dims
                          else int_indexers.get(d, slice(None))
                          for d in var.dims)
              needs_masking = any(d in masked_dims for d in var.dims)
  
              if needs_masking:
                  new_var = var._getitem_with_mask(key)
              elif all(is_full_slice(k) for k in key):
                  # no reindexing necessary
                  # here we need to manually deal with copying data, since
                  # we neither created a new ndarray nor used fancy indexing
                  new_var = var.copy(deep=copy)
              else:
                  new_var = var[key]
  
              reindexed[name] = new_var
  
      return reindexed, new_indexes