Using Token Bucket to rate limit function calls
Avoid casting time too much
A lot of code is spent on converting time to integers. Avoid casting too early; store time as much as possible as std::chrono types.
In fact, intead of storing how much tokens there are in the bucket, you could instead store how much time there is in the bucket. Then only in areTokensAvailable() do you need to cast from the amount of time in the bucket to the number of tokens.
For example, the result of two calls to std::chrono::...::now() can be subtracted from each other, the result is a duration that can be added to another duration.
Consider using shorter function and variable names
Your function and variable names are very verbose, to the point that they make the code harder to read. Try to make them more concise, remove redundant information. I would also avoid using prefixes such as fa_. Does it stand for function argument? It's already clear from the function definition that it's an argument. The m_ prefx for private member variables is more commonly used, and sometimes helps avoid name clashes, so I would keep that.
Use a single type to store the number of tokens
In your code, you use both uint64_t and int for the number of tokens. Be consistent and stick with a single type. Use a type alias to make it more explicit.
Use std::chrono::steady_clock
Don't use std::chrono::system_clock for measuring the passage of time. It will give incorrect results when daylight savings time changes, when there are leap seconds and whenever the system clock gets changed (either by an administrator or by something like an NTP daemon). The std::chrono::steady_clock is guaranteed to be a monotonically increasiing clock. I would also create a type alias for it to reduce typing.
Example
Here's an example of how the code can be made to look:
class tokenBucket {
    using count_type = uint64_t;
    using clock = std::chrono::steady_clock;

public:
    tokenBucket(count_type rate): m_rate(rate) {}

    bool request(count_type count) {
        std::lock_guard&lt;std::mutex&gt; lock(m_mutex);
        refill();
        return try_remove(count);
    }

private:
    std::mutex m_mutex;

    count_type m_rate;
    clock::time_point m_last_refill{clock::now()};
    clock::duration m_available{};
    clock::duration m_capacity{std::chrono::seconds(1)};

    void refill() {
        auto now = clock::now();
        m_available += now - m_last_refill;
        m_available = std::min(m_available, m_capacity);
        m_last_refill = now;
    }

    bool try_remove(count_type count) {
        auto requested = count * clock::duration(std::chrono::seconds(1)) / m_rate;

        if (requested &lt;= m_available) {
            m_available -= requested;
            return true;
        } else {
            return false;
        }
    }    
};

Note: m_capacity here holds the size of the bucket as a time duration. If it is constant, you can make it a static constexpr variable.