declare namespace java {
    namespace util {
        namespace concurrent {
            // @ts-ignore
             class CopyOnWriteArraySet extends java.util.AbstractSet {
                /**
                 * Creates an empty set.
                 */
                // @ts-ignore
                constructor()
                /**
                 * Creates a set containing all of the elements of the specified
                 * collection.
                 */
                // @ts-ignore
                constructor(c: java.util.Collection)
                /**
                 * Returns the number of elements in this set.
                 */
                // @ts-ignore
                public size(): number;
                /**
                 * Returns {@code true} if this set contains no elements.
                 */
                // @ts-ignore
                public isEmpty(): boolean;
                /**
                 * Returns {@code true} if this set contains the specified element.
                 * More formally, returns {@code true} if and only if this set
                 * contains an element {@code e} such that
                 * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
                 */
                // @ts-ignore
                public contains(o: java.lang.Object): boolean;
                /**
                 * Returns an array containing all of the elements in this set.
                 * If this set makes any guarantees as to what order its elements
                 * are returned by its iterator, this method must return the
                 * elements in the same order.
                 * <p>The returned array will be "safe" in that no references to it
                 * are maintained by this set.  (In other words, this method must
                 * allocate a new array even if this set is backed by an array).
                 * The caller is thus free to modify the returned array.
                 * <p>This method acts as bridge between array-based and collection-based
                 * APIs.
                 */
                // @ts-ignore
                public toArray(): java.lang.Object[];
                /**
                 * Returns an array containing all of the elements in this set; the
                 * runtime type of the returned array is that of the specified array.
                 * If the set fits in the specified array, it is returned therein.
                 * Otherwise, a new array is allocated with the runtime type of the
                 * specified array and the size of this set.
                 * <p>If this set fits in the specified array with room to spare
                 * (i.e., the array has more elements than this set), the element in
                 * the array immediately following the end of the set is set to
                 * {@code null}.  (This is useful in determining the length of this
                 * set <i>only</i> if the caller knows that this set does not contain
                 * any null elements.)
                 * <p>If this set makes any guarantees as to what order its elements
                 * are returned by its iterator, this method must return the elements
                 * in the same order.
                 * <p>Like the {@link #toArray()} method, this method acts as bridge between
                 * array-based and collection-based APIs.  Further, this method allows
                 * precise control over the runtime type of the output array, and may,
                 * under certain circumstances, be used to save allocation costs.
                 * <p>Suppose {@code x} is a set known to contain only strings.
                 * The following code can be used to dump the set into a newly allocated
                 * array of {@code String}:
                 * <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
                 * Note that {@code toArray(new Object[0])} is identical in function to
                 * {@code toArray()}.
                 */
                // @ts-ignore
                public toArray(a: java.lang.Object): java.lang.Object[];
                /**
                 * Removes all of the elements from this set.
                 * The set will be empty after this call returns.
                 */
                // @ts-ignore
                public clear(): void;
                /**
                 * Removes the specified element from this set if it is present.
                 * More formally, removes an element {@code e} such that
                 * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>,
                 * if this set contains such an element.  Returns {@code true} if
                 * this set contained the element (or equivalently, if this set
                 * changed as a result of the call).  (This set will not contain the
                 * element once the call returns.)
                 */
                // @ts-ignore
                public remove(o: java.lang.Object): boolean;
                /**
                 * Adds the specified element to this set if it is not already present.
                 * More formally, adds the specified element {@code e} to this set if
                 * the set contains no element {@code e2} such that
                 * <tt>(e==null&nbsp;?&nbsp;e2==null&nbsp;:&nbsp;e.equals(e2))</tt>.
                 * If this set already contains the element, the call leaves the set
                 * unchanged and returns {@code false}.
                 */
                // @ts-ignore
                public add(e: java.lang.Object): boolean;
                /**
                 * Returns {@code true} if this set contains all of the elements of the
                 * specified collection.  If the specified collection is also a set, this
                 * method returns {@code true} if it is a <i>subset</i> of this set.
                 */
                // @ts-ignore
                public containsAll(c: java.util.Collection): boolean;
                /**
                 * Adds all of the elements in the specified collection to this set if
                 * they're not already present.  If the specified collection is also a
                 * set, the {@code addAll} operation effectively modifies this set so
                 * that its value is the <i>union</i> of the two sets.  The behavior of
                 * this operation is undefined if the specified collection is modified
                 * while the operation is in progress.
                 */
                // @ts-ignore
                public addAll(c: java.util.Collection): boolean;
                /**
                 * Removes from this set all of its elements that are contained in the
                 * specified collection.  If the specified collection is also a set,
                 * this operation effectively modifies this set so that its value is the
                 * <i>asymmetric set difference</i> of the two sets.
                 */
                // @ts-ignore
                public removeAll(c: java.util.Collection): boolean;
                /**
                 * Retains only the elements in this set that are contained in the
                 * specified collection.  In other words, removes from this set all of
                 * its elements that are not contained in the specified collection.  If
                 * the specified collection is also a set, this operation effectively
                 * modifies this set so that its value is the <i>intersection</i> of the
                 * two sets.
                 */
                // @ts-ignore
                public retainAll(c: java.util.Collection): boolean;
                /**
                 * Returns an iterator over the elements contained in this set
                 * in the order in which these elements were added.
                 * <p>The returned iterator provides a snapshot of the state of the set
                 * when the iterator was constructed. No synchronization is needed while
                 * traversing the iterator. The iterator does <em>NOT</em> support the
                 * {@code remove} method.
                 */
                // @ts-ignore
                public iterator(): java.util.Iterator;
                /**
                 * Compares the specified object with this set for equality.
                 * Returns {@code true} if the specified object is the same object
                 * as this object, or if it is also a {@link Set} and the elements
                 * returned by an {@linkplain Set#iterator() iterator} over the
                 * specified set are the same as the elements returned by an
                 * iterator over this set.  More formally, the two iterators are
                 * considered to return the same elements if they return the same
                 * number of elements and for every element {@code e1} returned by
                 * the iterator over the specified set, there is an element
                 * {@code e2} returned by the iterator over this set such that
                 * {@code (e1==null ? e2==null : e1.equals(e2))}.
                 */
                // @ts-ignore
                public equals(o: java.lang.Object): boolean;
                // @ts-ignore
                public removeIf(filter: java.util.function$.Predicate): boolean;
                // @ts-ignore
                public forEach(action: java.util.function$.Consumer): void;
                /**
                 * Returns a {@link Spliterator} over the elements in this set in the order
                 * in which these elements were added.
                 * <p>The {@code Spliterator} reports {@link Spliterator#IMMUTABLE},
                 * {@link Spliterator#DISTINCT}, {@link Spliterator#SIZED}, and
                 * {@link Spliterator#SUBSIZED}.
                 * <p>The spliterator provides a snapshot of the state of the set
                 * when the spliterator was constructed. No synchronization is needed while
                 * operating on the spliterator.
                 */
                // @ts-ignore
                public spliterator(): java.util.Spliterator;
            }
        }
    }
}
