/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/DefaultConstructible
class DefaultConstructible {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/CopyConstructible
class CopyConstructible {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/CopyAssignable
class CopyAssignable {};

///This concept refines both `CopyAssignable` and `CopyConstructible`.
class Assignable {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/Callable
class Callable {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/EqualityComparable
class EqualityComparable {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/LessThanComparable
class LessThanComparable {};

/// \cgalConcept
/// The concept `AdaptableFunctor` defines an adaptable functor, that is, a functor that can be
/// used with function object adaptors such as binders and composers.
///
class AdaptableFunctor {};

/// \cgalConcept
/// Adaptable functor with one argument
/// \cgalRefines{AdaptableFunctor}
class AdaptableUnaryFunction
{
public:
  /// result_type
  typedef unspecified_type result_type;
  /// argument_type
  typedef unspecified_type argument_type;
  /// operator type
  result_type operator()(argument_type);
};

/// \cgalConcept
/// Adaptable functor with two arguments
/// \cgalRefines{AdaptableFunctor}
class AdaptableBinaryFunction
{
public:
  /// result_type
  typedef unspecified_type result_type;
  /// first argument_type
  typedef unspecified_type first_argument_type;
  /// second argument_type
  typedef unspecified_type second_argument_type;
  /// operator type
  result_type operator()(first_argument_type, second_argument_type);
};

/// \cgalConcept
/// Adaptable functor with three arguments
/// \cgalRefines{AdaptableFunctor}
class AdaptableTernaryFunction
{
public:
  /// result_type
  typedef unspecified_type result_type;
  /// first argument_type
  typedef unspecified_type first_argument_type;
  /// second argument_type
  typedef unspecified_type second_argument_type;
  /// third argument_type
  typedef unspecified_type third_argument_type;
  /// operator type
  result_type operator()(first_argument_type, second_argument_type, third_argument_type);
};

/// \cgalConcept
/// Adaptable functor with four arguments
/// \cgalRefines{AdaptableFunctor}
class AdaptableQuaternaryFunction
{
public:
  /// result_type
  typedef unspecified_type result_type;
  /// first argument_type
  typedef unspecified_type first_argument_type;
  /// second argument_type
  typedef unspecified_type second_argument_type;
  /// third argument_type
  typedef unspecified_type third_argument_type;
  /// fourth argument_type
  typedef unspecified_type fourth_argument_type;
  /// operator type
  result_type operator()(first_argument_type, second_argument_type, third_argument_type, fourth_argument_type);
};

/// \cgalConcept
/// Adaptable functor with five arguments
/// \cgalRefines{AdaptableFunctor}
class AdaptableQuinaryFunction
{
public:
  /// result_type
  typedef unspecified_type result_type;
  /// first argument_type
  typedef unspecified_type first_argument_type;
  /// second argument_type
  typedef unspecified_type second_argument_type;
  /// third argument_type
  typedef unspecified_type third_argument_type;
  /// fourth argument_type
  typedef unspecified_type fourth_argument_type;
  /// fifth argument_type
  typedef unspecified_type fifth_argument_type;
  /// operator type
  result_type operator()(first_argument_type, second_argument_type, third_argument_type, fourth_argument_type, fifth_argument_type);
};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/Iterator
class Iterator {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/OutputIterator
class OutputIterator {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/InputIterator
class InputIterator {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/ForwardIterator
class ForwardIterator {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator
class RandomAccessIterator {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator
class BidirectionalIterator {};

/// \cgalConcept
/// A regular type is a type similar to `int`: it is copyable, assignable, and equality comparable.
/// \cgalRefines{DefaultConstructible, CopyConstructible, CopyAssignable, EqualityComparable}
/// See also the C++ concept `std::regular` at https://en.cppreference.com/w/cpp/concepts/regular
class Regular {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/Swappable
class Swappable {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/Container
class Container {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/ReversibleContainer
class ReversibleContainer {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/AssociativeContainer
class AssociativeContainer {};

/// \cgalConcept
/// Concept from the \cpp standard.
/// See https://en.cppreference.com/w/cpp/named_req/SequenceContainer
class SequenceContainer {};

/// \cgalConcept
/// This container concept refines
/// <a href="https://en.cppreference.com/w/cpp/named_req/ReversibleContainer"><tt>ReversibleContainer</tt></a> and its iterator type is a model of
/// <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator"><tt>RandomAccessIterator</tt></a>.
class RandomAccessContainer {};

/// \cgalConcept
/// This container concepts refines
/// <a href="https://en.cppreference.com/w/cpp/named_req/SequenceContainer"><tt>SequenceContainer</tt></a> and
/// has the ability to append elements at the end of the sequence and to access the last element, both in amortized constant time.
class BackInsertionSequence
{
public:
  /// returns the last inserted element.
  const value_type& back() const;
  /// removes the last inserted element if not empty.
  void pop_back()
  /// inserts an element
  void push_back(const value_type&)
};

/*!
See https://www.boost.org/libs/property_map/doc/LvaluePropertyMap.html
\cgalConcept
*/
class LvaluePropertyMap {};

/*!
See https://www.boost.org/libs/property_map/doc/ReadWritePropertyMap.html
\cgalConcept
*/
class ReadWritePropertyMap {};

/*!
See https://www.boost.org/libs/property_map/doc/WritablePropertyMap.html
\cgalConcept
*/
class WritablePropertyMap {};

/*!
See https://www.boost.org/libs/property_map/doc/ReadablePropertyMap.html
\cgalConcept
*/
class ReadablePropertyMap {};

/*!
See https://www.boost.org/libs/range/doc/html/range/concepts/single_pass_range.html
\cgalConcept
*/
class SinglePassRange {};

/*!
See https://www.boost.org/libs/range/doc/html/range/concepts/random_access_range.html
\cgalConcept
*/
class RandomAccessRange {};

/*!
See https://www.boost.org/libs/range/doc/html/range/concepts/forward_range.html
\cgalConcept
*/
class ForwardRange {};

/*!
Concept from the Boost Graph Library.
See https://www.boost.org/libs/graph/doc/IncidenceGraph.html
\cgalConcept
*/
class IncidenceGraph {};

/*!
Concept from the Boost Graph Library.
See https://www.boost.org/libs/graph/doc/BidirectionalGraph.html
\cgalConcept
*/
class BidirectionalGraph {};

/*!
Concept from the Boost Graph Library.
See https://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html
\cgalConcept
*/
class VertexAndEdgeListGraph {};

/*!
Concept from the Boost Graph Library.
See https://www.boost.org/libs/graph/doc/AdjacencyGraph.html
\cgalConcept
*/
class AdjacencyGraph {};

/*!
Concept from the Boost Graph Library.
See https://www.boost.org/libs/graph/doc/AdjacencyMatrix.html
\cgalConcept
*/
class AdjacencyMatrix {};

/*!
Concept from the Boost Graph Library.
See https://www.boost.org/libs/graph/doc/MutableGraph.html
\cgalConcept
*/
class MutableGraph {};

/*!
Concept from the Boost Graph Library.
See https://www.boost.org/libs/graph/doc/PropertyGraph.html
\cgalConcept
*/
class PropertyGraph {};

/*!
Concept from the Boost Graph Library.
See https://www.boost.org/libs/graph/doc/MutablePropertyGraph.html
\cgalConcept
*/
class MutablePropertyGraph {};

/*!
This indicates that the definition of a type nested in a class is not documented.
*/
class unspecified_type {};
