/**@class java.util.stream.StreamSupport
@extends java.lang.Object

 Low-level utility methods for creating and manipulating streams.

 <p>This class is mostly for library writers presenting stream views
 of data structures; most static stream methods intended for end users are in
 the various {@code Stream} classes.

 @since 1.8
*/
var StreamSupport = {

/**Creates a new sequential or parallel {@code Stream} from a
 {@code Spliterator}.

 <p>The spliterator is only traversed, split, or queried for estimated
 size after the terminal operation of the stream pipeline commences.

 <p>It is strongly recommended the spliterator report a characteristic of
 {@code IMMUTABLE} or {@code CONCURRENT}, or be
 <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
 {@link #stream(java.util.function.Supplier, int, boolean)} should be used
 to reduce the scope of potential interference with the source.  See
 <a href="package-summary.html#NonInterference">Non-Interference</a> for
 more details.
@param {Object {java.util.Spliterator}} spliterator a {@code Spliterator} describing the stream elements
@param {Boolean} parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@param parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@return {Object {java.util.stream.Stream}} a new sequential or parallel {@code Stream}
*/
stream : function(  ) {},

/**Creates a new sequential or parallel {@code Stream} from a
 {@code Supplier} of {@code Spliterator}.

 <p>The {@link Supplier#get()} method will be invoked on the supplier no
 more than once, and only after the terminal operation of the stream pipeline
 commences.

 <p>For spliterators that report a characteristic of {@code IMMUTABLE}
 or {@code CONCURRENT}, or that are
 <a href="../Spliterator.html#binding">late-binding</a>, it is likely
 more efficient to use {@link #stream(java.util.Spliterator, boolean)}
 instead.
 <p>The use of a {@code Supplier} in this form provides a level of
 indirection that reduces the scope of potential interference with the
 source.  Since the supplier is only invoked after the terminal operation
 commences, any modifications to the source up to the start of the
 terminal operation are reflected in the stream result.  See
 <a href="package-summary.html#NonInterference">Non-Interference</a> for
 more details.
@param {Object {java.util.function.Supplier}} supplier a {@code Supplier} of a {@code Spliterator}
@param {Number} characteristics Spliterator characteristics of the supplied
        {@code Spliterator}.  The characteristics must be equal to
        {@code supplier.get().characteristics()}, otherwise undefined
        behavior may occur when terminal operation commences.
@param {Boolean} parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@param parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@return {Object {java.util.stream.Stream}} a new sequential or parallel {@code Stream}
@see #stream(java.util.Spliterator, boolean)
*/
stream : function(  ) {},

/**Creates a new sequential or parallel {@code IntStream} from a
 {@code Spliterator.OfInt}.

 <p>The spliterator is only traversed, split, or queried for estimated size
 after the terminal operation of the stream pipeline commences.

 <p>It is strongly recommended the spliterator report a characteristic of
 {@code IMMUTABLE} or {@code CONCURRENT}, or be
 <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
 {@link #intStream(java.util.function.Supplier, int, boolean)} should be
 used to reduce the scope of potential interference with the source.  See
 <a href="package-summary.html#NonInterference">Non-Interference</a> for
 more details.
@param {Object {Spliterator.OfInt}} spliterator a {@code Spliterator.OfInt} describing the stream elements
@param {Boolean} parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@return {Object {java.util.stream.IntStream}} a new sequential or parallel {@code IntStream}
*/
intStream : function(  ) {},

/**Creates a new sequential or parallel {@code IntStream} from a
 {@code Supplier} of {@code Spliterator.OfInt}.

 <p>The {@link Supplier#get()} method will be invoked on the supplier no
 more than once, and only after the terminal operation of the stream pipeline
 commences.

 <p>For spliterators that report a characteristic of {@code IMMUTABLE}
 or {@code CONCURRENT}, or that are
 <a href="../Spliterator.html#binding">late-binding</a>, it is likely
 more efficient to use {@link #intStream(java.util.Spliterator.OfInt, boolean)}
 instead.
 <p>The use of a {@code Supplier} in this form provides a level of
 indirection that reduces the scope of potential interference with the
 source.  Since the supplier is only invoked after the terminal operation
 commences, any modifications to the source up to the start of the
 terminal operation are reflected in the stream result.  See
 <a href="package-summary.html#NonInterference">Non-Interference</a> for
 more details.
@param {Object {java.util.function.Supplier}} supplier a {@code Supplier} of a {@code Spliterator.OfInt}
@param {Number} characteristics Spliterator characteristics of the supplied
        {@code Spliterator.OfInt}.  The characteristics must be equal to
        {@code supplier.get().characteristics()}, otherwise undefined
        behavior may occur when terminal operation commences.
@param {Boolean} parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@return {Object {java.util.stream.IntStream}} a new sequential or parallel {@code IntStream}
@see #intStream(java.util.Spliterator.OfInt, boolean)
*/
intStream : function(  ) {},

/**Creates a new sequential or parallel {@code LongStream} from a
 {@code Spliterator.OfLong}.

 <p>The spliterator is only traversed, split, or queried for estimated
 size after the terminal operation of the stream pipeline commences.

 <p>It is strongly recommended the spliterator report a characteristic of
 {@code IMMUTABLE} or {@code CONCURRENT}, or be
 <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
 {@link #longStream(java.util.function.Supplier, int, boolean)} should be
 used to reduce the scope of potential interference with the source.  See
 <a href="package-summary.html#NonInterference">Non-Interference</a> for
 more details.
@param {Object {Spliterator.OfLong}} spliterator a {@code Spliterator.OfLong} describing the stream elements
@param {Boolean} parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@return {Object {java.util.stream.LongStream}} a new sequential or parallel {@code LongStream}
*/
longStream : function(  ) {},

/**Creates a new sequential or parallel {@code LongStream} from a
 {@code Supplier} of {@code Spliterator.OfLong}.

 <p>The {@link Supplier#get()} method will be invoked on the supplier no
 more than once, and only after the terminal operation of the stream pipeline
 commences.

 <p>For spliterators that report a characteristic of {@code IMMUTABLE}
 or {@code CONCURRENT}, or that are
 <a href="../Spliterator.html#binding">late-binding</a>, it is likely
 more efficient to use {@link #longStream(java.util.Spliterator.OfLong, boolean)}
 instead.
 <p>The use of a {@code Supplier} in this form provides a level of
 indirection that reduces the scope of potential interference with the
 source.  Since the supplier is only invoked after the terminal operation
 commences, any modifications to the source up to the start of the
 terminal operation are reflected in the stream result.  See
 <a href="package-summary.html#NonInterference">Non-Interference</a> for
 more details.
@param {Object {java.util.function.Supplier}} supplier a {@code Supplier} of a {@code Spliterator.OfLong}
@param {Number} characteristics Spliterator characteristics of the supplied
        {@code Spliterator.OfLong}.  The characteristics must be equal to
        {@code supplier.get().characteristics()}, otherwise undefined
        behavior may occur when terminal operation commences.
@param {Boolean} parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@return {Object {java.util.stream.LongStream}} a new sequential or parallel {@code LongStream}
@see #longStream(java.util.Spliterator.OfLong, boolean)
*/
longStream : function(  ) {},

/**Creates a new sequential or parallel {@code DoubleStream} from a
 {@code Spliterator.OfDouble}.

 <p>The spliterator is only traversed, split, or queried for estimated size
 after the terminal operation of the stream pipeline commences.

 <p>It is strongly recommended the spliterator report a characteristic of
 {@code IMMUTABLE} or {@code CONCURRENT}, or be
 <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
 {@link #doubleStream(java.util.function.Supplier, int, boolean)} should
 be used to reduce the scope of potential interference with the source.  See
 <a href="package-summary.html#NonInterference">Non-Interference</a> for
 more details.
@param {Object {Spliterator.OfDouble}} spliterator A {@code Spliterator.OfDouble} describing the stream elements
@param {Boolean} parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@return {Object {java.util.stream.DoubleStream}} a new sequential or parallel {@code DoubleStream}
*/
doubleStream : function(  ) {},

/**Creates a new sequential or parallel {@code DoubleStream} from a
 {@code Supplier} of {@code Spliterator.OfDouble}.

 <p>The {@link Supplier#get()} method will be invoked on the supplier no
 more than once, and only after the terminal operation of the stream pipeline
 commences.

 <p>For spliterators that report a characteristic of {@code IMMUTABLE}
 or {@code CONCURRENT}, or that are
 <a href="../Spliterator.html#binding">late-binding</a>, it is likely
 more efficient to use {@link #doubleStream(java.util.Spliterator.OfDouble, boolean)}
 instead.
 <p>The use of a {@code Supplier} in this form provides a level of
 indirection that reduces the scope of potential interference with the
 source.  Since the supplier is only invoked after the terminal operation
 commences, any modifications to the source up to the start of the
 terminal operation are reflected in the stream result.  See
 <a href="package-summary.html#NonInterference">Non-Interference</a> for
 more details.
@param {Object {java.util.function.Supplier}} supplier A {@code Supplier} of a {@code Spliterator.OfDouble}
@param {Number} characteristics Spliterator characteristics of the supplied
        {@code Spliterator.OfDouble}.  The characteristics must be equal to
        {@code supplier.get().characteristics()}, otherwise undefined
        behavior may occur when terminal operation commences.
@param {Boolean} parallel if {@code true} then the returned stream is a parallel
        stream; if {@code false} the returned stream is a sequential
        stream.
@return {Object {java.util.stream.DoubleStream}} a new sequential or parallel {@code DoubleStream}
@see #doubleStream(java.util.Spliterator.OfDouble, boolean)
*/
doubleStream : function(  ) {},


};