#include <chrono>

class A
{
public:
  static const unsigned TIMEOUT = 300;
};


void foo(std::chrono::milliseconds timeout)
{
}


void boo()
{
  foo( std::chrono::milliseconds(+A::TIMEOUT) );
}

If a non-volatile non-inline const static data member is of integral or enumeration type, its declaration in the class definition can specify a brace-or-equal-initializer in which every initializer-clause that is an assignment-expression is a constant expression (8.20). The member shall still be defined in a namespace scope if it is odr-used (6.2) in the program and the namespace scope definition shall not contain an initializer. An inline static data member may be defined in the class definition and may specify a brace-or-equal-initializer. If the member is declared with the constexpr specifier, it may be redeclared in namespace scope with no initializer (this usage is deprecated; see D.1). Declarations of other static data members shall not specify a brace-or-equal-initializer.

template<class Rep2>
constexpr explicit duration (const Rep2& n);

//static
const unsigned A::TIMEOUT;

void boo()
{
  auto t = A::TIMEOUT;
  foo( std::chrono::milliseconds(t) );
}

class A
{
public:
  static inline    unsigned TIMEOUT = 300;
  // или 
  static constexpr unsigned TIMEOUT = 300;
};

8.5.3 References
/5
. . .
— If the initializer expression is an rvalue, with T2 a class type, and “cv1 T1” is referencecompatible with “cv2 T2,” the reference is bound in one of the following ways (the choice is implementationdefined):
— The reference is bound to the object represented by the rvalue (see 3.10) or to a subobject within that object.
— A temporary of type “cv1 T2” [sic] is created, and a constructor is called to copy the entire rvalue object into the temporary. The reference is bound to the temporary or to a subobject within the temporary.93)

constexpr duration() = default;

duration( const duration& ) = default;

template< class Rep2 >
constexpr explicit duration( const Rep2& r );

template< class Rep2, class Period2 >
constexpr duration( const duration<Rep2,Period2>& d );

#include <iostream>
#include <chrono>
using namespace std;
 
template<class T>
struct C {
    C() {}
    template<class U> C(const C<U>&) {}
    template<typename T2> constexpr explicit C(const T2& t) {}  // у chrono::duration там ещё enable_if, но для пары (unsigned, long) он выполняется
};
 
using Z = chrono::milliseconds;
using S = C<unsigned long>;
 
void foo(Z) {}
void bar(S) {}
 
static const unsigned t1 = 1;
int main() {
    foo(Z(t1));  // foo(t1); foo(1L);
    bar(S(t1));  // bar(t2); bar(1L);
}

К>constexpr duration() = default;

К>duration( const duration& ) = default;

К>template< class Rep2 >
К>constexpr explicit duration( const Rep2& r );

К>template< class Rep2, class Period2 >
К>constexpr duration( const duration<Rep2,Period2>& d );
К>

К>#include <iostream>
К>#include <chrono>
К>using namespace std;
 
К>template<class T>
К>struct C {
К>    C() {}
К>    template<class U> C(const C<U>&) {}
К>    template<typename T2> constexpr explicit C(const T2& t) {}  // у chrono::duration там ещё enable_if, но для пары (unsigned, long) он выполняется
К>};
 
К>using Z = chrono::milliseconds;
К>using S = C<unsigned long>;
 
К>void foo(Z) {}
К>void bar(S) {}
 
К>static const unsigned t1 = 1;
К>int main() {
К>    foo(Z(t1));  // foo(t1); foo(1L);
К>    bar(S(t1));  // bar(t2); bar(1L);
К>}
К>

static const unsigned t1 = 1;

struct A {
  static const int value = 42;
};

void foo(const int&) {}

int main() {
  foo(+A::value);
}