How to use io.sphere.sdk.search

Range(final Optional<Bound<T>> lowerBound, final Optional<Bound<T>> upperBound) {
  this.lowerBound = lowerBound;
  this.upperBound = upperBound;
  if (hasInvertedBounds()) {
    throw new InvertedBoundsException(this);
  }
  if (hasSameExclusiveBounds()) {
    throw new SameExclusiveBoundsException(this);
  }
}

  @Override
  public B sort(final List<SortExpression<T>> sortExpressions) {
    return op(d -> d.withSort(sortExpressions));
  }
}

@Override
public C withFacetFilters(final List<FilterExpression<T>> filterExpressions) {
  return copyBuilder().facetFilters(filterExpressions).build();
}

@Override
public C withSort(final List<SortExpression<T>> sortExpressions) {
  return copyBuilder().sort(sortExpressions).build();
}

@Override
public C withOffset(final Long offset) {
  return copyBuilder().offset(offset).build();
}

@Override
public C withFacetedSearch(final List<FacetedSearchExpression<T>> facetedSearchExpressions) {
  return copyBuilder().facetedSearch(facetedSearchExpressions).build();
}

@Override
public B plusExpansionPaths(final List<ExpansionPath<T>> expansionPaths) {
  return op(d -> d.plusExpansionPaths(expansionPaths));
}

@Override
public B expansionPaths(final ExpansionPath<T> expansionPath) {
  return op(d -> d.withExpansionPaths(expansionPath));
}

@Override
public B plusSort(final List<SortExpression<T>> sortExpressions) {
  return op(d -> d.plusSort(sortExpressions));
}

@Override
public B plusFacetedSearch(final List<FacetedSearchExpression<T>> facetedSearchExpressions) {
  return op(d -> d.plusFacetedSearch(facetedSearchExpressions));
}

@Override
public B facetedSearch(final List<FacetedSearchExpression<T>> facetedSearchExpressions) {
  return op(d -> d.withFacetedSearch(facetedSearchExpressions));
}

@Override
public B facetFilters(final Function<L, List<FilterExpression<T>>> m) {
  return op(d -> d.withFacetFilters(m));
}

@Override
public B facets(final FacetExpression<T> facetExpression) {
  return op(d -> d.withFacets(facetExpression));
}

@Override
public B queryFilters(final Function<L, List<FilterExpression<T>>> m) {
  return op(d -> d.withQueryFilters(m));
}

@Override
public B fuzzyLevel(final Integer fuzzyLevel) {
  return op(d -> d.withFuzzyLevel(fuzzyLevel));
}

@Override
public B plusFacetFilters(final Function<L, List<FilterExpression<T>>> m) {
  return op(d -> d.plusFacetFilters(m));
}

@Override
public B plusExpansionPaths(final ExpansionPath<T> expansionPath) {
  return op(d -> d.plusExpansionPaths(expansionPath));
}

@Override
public B sort(final Function<S, SortExpression<T>> m) {
  return op(d -> d.withSort(m));
}

@Override
public B expansionPaths(final Function<E, ExpansionPathContainer<T>> m) {
  return op(d -> d.withExpansionPaths(m));
}

@Override
public B plusExpansionPaths(final Function<E, ExpansionPathContainer<T>> m) {
  return op(d -> d.plusExpansionPaths(m));
}