mp_units::operator*

[[nodiscard]]
constexpr
safe_int</* implementation-defined */, ErrorPolicy>
operator*(
    U lhs,
    safe_int rhs);

[[nodiscard]]
constexpr
auto
operator*(
    U lhs,
    safe_int rhs)
requires requires { lhs * static_cast<U>(rhs.value_); };

[[nodiscard]]
consteval
/* implementation-defined */
operator*(
    U1 lhs,
    reference rhs);

[[nodiscard]]
consteval
/* implementation-defined */
operator*(
    reference lhs,
    U2 rhs);

[[nodiscard]]
consteval
/* implementation-defined */
operator*(
    reference lhs,
    reference<Q2, U2> rhs);

[[nodiscard]]
constexpr
safe_int</* implementation-defined */, ErrorPolicy>
operator*(
    safe_int lhs,
    U rhs);

[[nodiscard]]
constexpr
auto
operator*(
    safe_int lhs,
    U rhs)
requires requires { static_cast<U>(lhs.value_) * rhs; };

[[nodiscard]]
constexpr
safe_int</* implementation-defined */, ErrorPolicy>
operator*(
    safe_int lhs,
    safe_int rhs);

[[nodiscard]]
constexpr
safe_int</* implementation-defined */, ErrorPolicy>
operator*(
    safe_int lhs,
    constrained<U, CP> rhs);

[[nodiscard]]
constexpr
constrained<decltype(std::declval<T>() * std::declval<U>()), CP>
operator*(
    safe_int lhs,
    constrained<U, CP> const& rhs);

[[nodiscard]]
constexpr
safe_int</* implementation-defined */, ErrorPolicy>
operator*(
    constrained<U, CP> lhs,
    safe_int rhs);

[[nodiscard]]
constexpr
constrained<decltype(std::declval<U>() * std::declval<T>()), CP>
operator*(
    constrained<U, CP> const& lhs,
    safe_int rhs);

template<
    Reference R,
    typename Q>
requires Quantity<std::remove_cvref_t<Q>>
constexpr
auto
operator*(
    R lhs,
    Q&& q) = delete;

template<
    Reference R,
    typename Rep>
requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(R{})>
constexpr
auto
operator*(
    R lhs,
    Rep&& rhs) = delete;

template<
    typename FwdQ,
    Reference R,
    Quantity Q = std::remove_cvref_t<FwdQ>>
[[nodiscard]]
constexpr
Quantity auto
operator*(
    FwdQ&& q,
    R rhs);

template<
    typename FwdRep,
    Reference R,
    RepresentationOf<get_quantity_spec(R{})> Rep = std::remove_cvref_t<FwdRep>>
requires (!detail::OffsetUnit<decltype(get_unit(R{}))>)
[[nodiscard]]
constexpr
quantity<R{}, Rep>
operator*(
    FwdRep&& lhs,
    R r);

template<
    typename FwdRep,
    Reference R,
    RepresentationOf<get_quantity_spec(R{})> Rep = std::remove_cvref_t<FwdRep>>
requires detail::OffsetUnit<decltype(get_unit(R{}))>
[[deprecated]]
constexpr
auto
operator*(
    FwdRep&& lhs,
    R r);