/lib/red5hx/java/util/concurrent/BlockingQueue.hx:8: lines 8-31 : Field remove has different type than in java.util.Collection
./lib/red5hx/java/util/concurrent/BlockingQueue.hx:8: lines 8-31 : Void -> java.util.concurrent.BlockingQueue.E should be arg0 : Dynamic -> Bool
./lib/red5hx/java/util/Queue.hx:6: lines 6-20 : Field remove has different type than in java.util.Collection
./lib/red5hx/java/util/Queue.hx:6: lines 6-20 : Void -> java.util.Queue.E should be arg0 : Dynamic -> Bool
//--------------------------------------------------------------------------
package java.util;

import java.util.Collection;

@:native("java.util.Queue")
extern interface Queue<E : (Dynamic)> implements Collection<E>
{
    function add(arg0:E):Bool;

    function element():E;

    function offer(arg0:E):Bool;

    function peek():E;

    function poll():E;

    function remove():E;

}
//--------------------------------------------------------------------------
package java.util;

import java.NativeArray;
import java.lang.Iterable;
import java.util.Iterator;

@:native("java.util.Collection")
extern interface Collection<E : (Dynamic)> implements java.lang.Iterable<E>
{
    function add(arg0:E):Bool;

    function addAll(arg0:Collection<E>):Bool;

    function clear():Void;

    function contains(arg0:Dynamic):Bool;

    function containsAll(arg0:Collection<Dynamic>):Bool;

    function equals(arg0:Dynamic):Bool;

    function hashCode():Int;

    function isEmpty():Bool;

    function iterator():java.util.Iterator<E>;

    function remove(arg0:Dynamic):Bool;

    function removeAll(arg0:Collection<Dynamic>):Bool;

    function retainAll(arg0:Collection<Dynamic>):Bool;

    function size():Int;

    @:overload(function toArray<T>(arg0:NativeArray<T>):NativeArray<T> {})
    function toArray():NativeArray<Dynamic>;

}



//---------------------------------------------------------------------------
package java.util.concurrent;

import java.util.Collection;
import java.util.Queue;
import java.util.concurrent.TimeUnit;

@:native("java.util.concurrent.BlockingQueue")
extern interface BlockingQueue<E : (Dynamic)> implements Queue<E>
{
    function add(arg0:E):Bool;

    function contains(arg0:Dynamic):Bool;

    @:overload(function drainTo(arg0:Collection<Dynamic>, arg1:Int):Int {})
    function drainTo(arg0:Collection<Dynamic>):Int;

    @:overload(function offer(arg0:E, arg1:haxe.Int64, arg2:TimeUnit):Bool {})
    function offer(arg0:E):Bool;

    @:overload(function poll(arg0:haxe.Int64, arg1:TimeUnit):E {})
    function poll():E;

    function put(arg0:E):Void;

    function remainingCapacity():Int;

    function remove():E;

    function take():E;

}