namespace Poco::Util::Units::Internal

namespace Internal {

// structs

template <
    typename Term,
    typename T1,
    typename T2
    >
struct CheckTermsEqual;

template <
    typename U,
    int N,
    int D,
    typename T1,
    typename T2
    >
struct CheckTermsEqual<Translate<U, N, D>, T1, T2>;

template <
    typename U,
    int N,
    int D,
    typename T1,
    typename T2
    >
struct CheckTermsEqual<Power<U, N, D>, T1, T2>;

template <
    typename U,
    int N,
    int D,
    typename T1,
    typename T2
    >
struct CheckTermsEqual<Scale<U, N, D>, T1, T2>;

template <
    typename T1,
    typename T2,
    typename T3,
    typename T4
    >
struct CheckTermsEqual<Compose<T1, T2>, T3, T4>;

template <typename T>
struct Convert<T, T>;

template <
    typename T1,
    typename T2
    >
struct Convert;

template <
    typename T,
    typename U,
    int Num,
    int Den
    >
struct Convert2<Scale<T, Num, Den>, U>;

template <
    typename T,
    typename U,
    int Num,
    int Den
    >
struct Convert2<Translate<T, Num, Den>, U>;

template <
    typename T1,
    typename T2
    >
struct Convert2;

template <
    typename T,
    typename U,
    int Num,
    int Den
    >
struct Convert3<T, Translate<U, Num, Den>>;

template <typename T>
struct Convert3<T, T>;

template <
    typename T1,
    typename T2
    >
struct Convert3;

template <
    typename T,
    typename U,
    int Num,
    int Den
    >
struct Convert3<T, Scale<U, Num, Den>>;

template <
    typename T1,
    typename T2
    >
struct Convertible;

template <
    typename Term,
    typename U,
    int N,
    int D
    >
struct CountTerms<Term, Scale<U, N, D>>;

template <
    typename Term,
    typename U,
    int N,
    int D
    >
struct CountTerms<Term, Translate<U, N, D>>;

template <
    typename Term,
    typename U,
    int N,
    int D
    >
struct CountTerms<Term, Power<U, N, D>>;

template <typename Term>
struct CountTerms<Term, Term>;

template <
    typename Term,
    typename T1,
    typename T2
    >
struct CountTerms<Term, Compose<T1, T2>>;

template <
    typename Term,
    typename List
    >
struct CountTerms;

template <
    int N,
    int D
    >
struct FixedPower<N, D, 2, 0>;

template <
    int N,
    int D
    >
struct FixedPower<N, D, 4, 0>;

template <
    int N,
    int D
    >
struct FixedPower<N, D, 1, 0>;

template <
    int N,
    int D
    >
struct FixedPower<N, D, 0, 0>;

template <
    int N,
    int D
    >
struct FixedPower<N, D, 3, 0>;

template <
    int N,
    int D
    >
struct FixedPower<N, D, -1, 0>;

template <
    int N,
    int D
    >
struct FixedPower<N, D, -2, 0>;

template <
    int Num,
    int Den,
    int Div,
    int Mod
    >
struct FixedPower;

template <
    typename U,
    int Num,
    int Den
    >
struct OutputUnit2<Scale<U, Num, Den>>;

template <
    typename U,
    int Num,
    int Den
    >
struct OutputUnit2<Translate<U, Num, Den>>;

template <
    typename U,
    int Num,
    int Den
    >
struct OutputUnit2<Power<U, Num, Den>>;

template <
    typename U1,
    typename U2
    >
struct OutputUnit2<Compose<U1, U2>>;

template <typename U>
struct OutputUnit2;

template <
    typename U,
    int N,
    int D
    >
struct ScalingFactor<Power<U, N, D>>;

template <
    typename U1,
    typename U2
    >
struct ScalingFactor<Compose<U1, U2>>;

template <
    typename U,
    int N,
    int D
    >
struct ScalingFactor<Scale<U, N, D>>;

template <typename U>
struct ScalingFactor;

template <
    typename U,
    int N,
    int D
    >
struct ScalingFactor<Translate<U, N, D>>;

} // namespace Internal