declare namespace java {
    namespace util {
        namespace concurrent {
            namespace atomic {
                /**
                 * One or more variables that together maintain an initially zero
                 * {@code long} sum.  When updates (method {@link #add}) are contended
                 * across threads, the set of variables may grow dynamically to reduce
                 * contention. Method {@link #sum} (or, equivalently, {@link
                 * #longValue}) returns the current total combined across the
                 * variables maintaining the sum.
                 * <p>This class is usually preferable to {@link AtomicLong} when
                 * multiple threads update a common sum that is used for purposes such
                 * as collecting statistics, not for fine-grained synchronization
                 * control.  Under low update contention, the two classes have similar
                 * characteristics. But under high contention, expected throughput of
                 * this class is significantly higher, at the expense of higher space
                 * consumption.
                 * <p>LongAdders can be used with a {@link
                 * java.util.concurrent.ConcurrentHashMap} to maintain a scalable
                 * frequency map (a form of histogram or multiset). For example, to
                 * add a count to a {@code ConcurrentHashMap<String,LongAdder> freqs},
                 * initializing if not already present, you can use {@code
                 * freqs.computeIfAbsent(k -> new LongAdder()).increment();}
                 * <p>This class extends {@link Number}, but does <em>not</em> define
                 * methods such as {@code equals}, {@code hashCode} and {@code
                 * compareTo} because instances are expected to be mutated, and so are
                 * not useful as collection keys.
                 * @since 1.8
                 * @author Doug Lea
                 */
                // @ts-ignore
                class LongAdder extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable {
                    /**
                     * Creates a new adder with initial sum of zero.
                     */
                    // @ts-ignore
                    constructor()
                    /**
                     * Adds the given value.
                     * @param x the value to add
                     */
                    // @ts-ignore
                    public add(x: number /*long*/): void
                    /**
                     * Equivalent to {@code add(1)}.
                     */
                    // @ts-ignore
                    public increment(): void
                    /**
                     * Equivalent to {@code add(-1)}.
                     */
                    // @ts-ignore
                    public decrement(): void
                    /**
                     * Returns the current sum.  The returned value is <em>NOT</em> an
                     * atomic snapshot; invocation in the absence of concurrent
                     * updates returns an accurate result, but concurrent updates that
                     * occur while the sum is being calculated might not be
                     * incorporated.
                     * @return the sum
                     */
                    // @ts-ignore
                    public sum(): number /*long*/
                    /**
                     * Resets variables maintaining the sum to zero.  This method may
                     * be a useful alternative to creating a new adder, but is only
                     * effective if there are no concurrent updates.  Because this
                     * method is intrinsically racy, it should only be used when it is
                     * known that no threads are concurrently updating.
                     */
                    // @ts-ignore
                    public reset(): void
                    /**
                     * Equivalent in effect to {@link #sum} followed by {@link
                     * #reset}. This method may apply for example during quiescent
                     * points between multithreaded computations.  If there are
                     * updates concurrent with this method, the returned value is
                     * <em>not</em> guaranteed to be the final value occurring before
                     * the reset.
                     * @return the sum
                     */
                    // @ts-ignore
                    public sumThenReset(): number /*long*/
                    /**
                     * Returns the String representation of the {@link #sum}.
                     * @return the String representation of the {#link #sum}
                     */
                    // @ts-ignore
                    public toString(): string
                    /**
                     * Equivalent to {@link #sum}.
                     * @return the sum
                     */
                    // @ts-ignore
                    public longValue(): number /*long*/
                    /**
                     * Returns the {@link #sum} as an {@code int} after a narrowing
                     * primitive conversion.
                     */
                    // @ts-ignore
                    public intValue(): number /*int*/
                    /**
                     * Returns the {@link #sum} as a {@code float}
                     * after a widening primitive conversion.
                     */
                    // @ts-ignore
                    public floatValue(): number /*float*/
                    /**
                     * Returns the {@link #sum} as a {@code double} after a widening
                     * primitive conversion.
                     */
                    // @ts-ignore
                    public doubleValue(): number /*double*/
                }
            }
        }
    }
}