Streams.widl

[Constructor(optional UnderlyingSource underlyingSource, optional QueuingStrategy strategy),
 Constructor(optional UnderlyingByteSource underlyingSource, optional QueuingStrategy strategy),
 Exposed=(Window,Worker)]
interface ReadableStream {
    readonly attribute boolean locked;
    Promise<void> cancel(optional any reason);
    ReadableStreamBYOBReader getReader(any options);
    ReadableStreamDefaultReader getReader();
    any pipeThrough(any pair, optional PipeOptions options);
    Promise<void> pipeTo(WritableStream dest, optional PipeOptions options);
    [ReadableStream, ReadableStream] tee();
};

callback QueuingStrategySizeCallback = double (any chunk);

dictionary QueuingStrategy {
	unrestricted double? highWaterMark;
	QueuingStrategySizeCallback? size;
};

callback ReadableByteStreamControllerCallback = any (ReadableByteStreamController controller);
callback ReadableStreamDefaultControllerCallback = any (ReadableStreamDefaultController controller);
callback ReadableStreamErrorCallback = any (any reason);

dictionary UnderlyingSource {
    ReadableStreamDefaultControllerCallback? start;
    ReadableStreamDefaultControllerCallback? pull;
    ReadableStreamErrorCallback? cancel;

    any type;
};

dictionary UnderlyingByteSource {
    ReadableByteStreamControllerCallback? start;
    ReadableByteStreamControllerCallback? pull;
    ReadableStreamErrorCallback? cancel;

    required DOMString type;
    unsigned long? autoAllocateChunkSize;
};

dictionary PipeOptions {
    boolean? preventClose;
    boolean? preventAbort;
    boolean? preventCancel;
    AbortSignal? signal;
};

dictionary ReadableStreamReadValueResult {
    required boolean done;
    required any value;
};

dictionary ReadableStreamReadDoneResult {
    required boolean done;
    any value;
};

[Exposed=(Window,Worker)]
typedef (ReadableStreamReadValueResult or ReadableStreamReadDoneResult) ReadableStreamReadResult;

[Exposed=(Window,Worker),
 NoInterfaceObject]
interface ReadableStreamDefaultReader {
    readonly attribute Promise<void> closed;

    Promise<void> cancel(optional any reason);
    Promise<ReadableStreamReadResult> read();
    void releaseLock();
};

[Exposed=(Window,Worker),
 NoInterfaceObject]
interface ReadableStreamBYOBReader {
    readonly attribute Promise<void> closed;

    Promise<void> cancel(optional any reason);
    Promise<ReadableStreamReadResult> read(ArrayBufferView view);
    void releaseLock();
};

[Exposed=(Window,Worker),
 NoInterfaceObject]
interface ReadableStreamDefaultController {
    readonly attribute unrestricted double? desiredSize;

    void close();
    void enqueue(any chunk);
    void error(optional any error);
};

[Exposed=(Window,Worker),
 NoInterfaceObject]
interface ReadableByteStreamController {
    readonly attribute ReadableStreamBYOBRequest byobRequest;
    readonly attribute unrestricted double? desiredSize;

    void close();
    void enqueue(ArrayBufferView chunk);
    void error(optional any error);
};

[Exposed=(Window,Worker),
 NoInterfaceObject]
interface ReadableStreamBYOBRequest {
    readonly attribute ArrayBufferView view;

    void respond(unsigned long bytesWritten);
    void respondWithNewView(ArrayBufferView view);
};

[Constructor(optional UnderlyingSink underlyingSink, optional QueuingStrategy strategy),
 Exposed=(Window,Worker)]
interface WritableStream {
    readonly attribute boolean locked;
    Promise<void> abort(optional any reason);
    Promise<void> close();
    WritableStreamDefaultWriter getWriter();
};

callback WritableStreamDefaultControllerStartCallback = any (WritableStreamDefaultController controller);
callback WritableStreamDefaultControllerWriteCallback = any (any chunk, WritableStreamDefaultController controller);
callback WritableStreamDefaultControllerCloseCallback = any ();
callback WritableStreamErrorCallback = any (any reason);

dictionary UnderlyingSink {
    WritableStreamDefaultControllerStartCallback? start;
    WritableStreamDefaultControllerWriteCallback? write;
    WritableStreamDefaultControllerCloseCallback? close;
    WritableStreamErrorCallback? abort;

    any type;
};

[Exposed=(Window,Worker),
 NoInterfaceObject]
interface WritableStreamDefaultWriter {
    readonly attribute Promise<void> closed;
    readonly attribute unrestricted double? desiredSize;
    readonly attribute Promise<void> ready;

    Promise<void> abort(optional any reason);
    Promise<void> close();
    void releaseLock();
    Promise<void> write(any chunk);
};

[Exposed=(Window,Worker),
 NoInterfaceObject]
interface WritableStreamDefaultController {
    void error(optional any error);
};

[Constructor(optional Transformer transformer, optional QueuingStrategy writableStrategy, optional QueuingStrategy readableStrategy),
 Exposed=(Window,Worker)]
interface TransformStream {
    readonly attribute ReadableStream readable;
    readonly attribute WritableStream writable;
};

callback TransformStreamDefaultControllerCallback = any (TransformStreamDefaultController controller);
callback TransformStreamDefaultControllerTransformCallback = any (any chunk, TransformStreamDefaultController controller);

dictionary Transformer {
    TransformStreamDefaultControllerCallback? start;
    TransformStreamDefaultControllerTransformCallback? transform;
    TransformStreamDefaultControllerCallback? flush;

    any readableType;
    any writableType;
};

[Exposed=(Window,Worker),
 NoInterfaceObject]
interface TransformStreamDefaultController {
    readonly attribute unrestricted double? desiredSize;

    void enqueue(any chunk);
    void error(optional any reason);
    void terminate();
};

[Constructor(any options),
 Exposed=(Window,Worker)]
interface ByteLengthQueuingStrategy: QueuingStrategy {
    attribute unrestricted double highWaterMark;
    double size(ArrayBufferView chunk);
};

[Constructor(any options),
 Exposed=(Window,Worker)]
interface CountQueuingStrategy: QueuingStrategy {
    attribute unrestricted double highWaterMark;
    double size(any chunk);
};