From 63b9a87e4fe7d658b368a15ee06f3edac2fcf098 Mon Sep 17 00:00:00 2001
From: Ruben Taelman <ruben.taelman@ugent.be>
Date: Thu, 30 Nov 2017 14:25:40 +0900
Subject: [PATCH] Make asynciterator methods public

---
 types/asynciterator/index.d.ts | 74 +++++++++++++++++-----------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/types/asynciterator/index.d.ts b/types/asynciterator/index.d.ts
index 005819aa21..950fb16bbd 100644
--- a/types/asynciterator/index.d.ts
+++ b/types/asynciterator/index.d.ts
@@ -9,16 +9,16 @@
 import { EventEmitter } from "events";
 
 export abstract class AsyncIterator<T> extends NodeJS.EventEmitter {
-    protected static STATES: ['INIT', 'OPEN', 'CLOSING', 'CLOSED', 'ENDED'];
-    protected static INIT: 0;
-    protected static OPEN: 1;
-    protected static CLOSING: 2;
-    protected static CLOSED: 3;
-    protected static ENDED: 4;
+    static STATES: ['INIT', 'OPEN', 'CLOSING', 'CLOSED', 'ENDED'];
+    static INIT: 0;
+    static OPEN: 1;
+    static CLOSING: 2;
+    static CLOSED: 3;
+    static ENDED: 4;
 
-    protected _state: number;
-    protected _readable: boolean;
-    protected _destination?: AsyncIterator<any>;
+    _state: number;
+    _readable: boolean;
+    _destination?: AsyncIterator<any>;
 
     readable: boolean;
     closed: boolean;
@@ -30,11 +30,11 @@ export abstract class AsyncIterator<T> extends NodeJS.EventEmitter {
     each(callback: (data: T) => void, self?: any): void;
     close(): void;
 
-    protected _changeState(newState: number, eventAsync?: boolean): void;
+    _changeState(newState: number, eventAsync?: boolean): void;
     private _hasListeners(eventName: string | symbol): boolean;
     // tslint:disable-next-line ban-types
     private _addSingleListener(eventName: string | symbol, listener: Function): void;
-    protected _end(): void;
+    _end(): void;
 
     getProperty(propertyName: string, callback?: (value: any) => void): any;
     setProperty(propertyName: string, value: any): void;
@@ -43,7 +43,7 @@ export abstract class AsyncIterator<T> extends NodeJS.EventEmitter {
     copyProperties(source: AsyncIterator<any>, propertyNames: string[]): void;
 
     toString(): string;
-    protected _toStringDetails(): string;
+    _toStringDetails(): string;
 
     transform<T2>(options?: SimpleTransformIteratorOptions<T, T2>): SimpleTransformIterator<T, T2>;
     map<T2>(mapper: (item: T) => T2, self?: object): SimpleTransformIterator<T, T2>;
@@ -78,9 +78,9 @@ export interface IntegerIteratorOptions {
 }
 
 export class IntegerIterator extends AsyncIterator<number> {
-    protected _step: number;
-    protected _last: number;
-    protected _next: number;
+    _step: number;
+    _last: number;
+    _next: number;
 
     constructor(options?: IntegerIteratorOptions);
 }
@@ -92,16 +92,16 @@ export interface BufferedIteratorOptions {
 
 export class BufferedIterator<T> extends AsyncIterator<T> {
     maxBufferSize: number;
-    protected _pushedCount: number;
-    protected _buffer: T[];
+    _pushedCount: number;
+    _buffer: T[];
 
-    protected _init(autoStart: boolean): void;
-    protected _begin(done: () => void): void;
-    protected _read(count: number, done: () => void): void;
-    protected _push(item: T): void;
-    protected _fillBuffer(): void;
-    protected _completeClose(): void;
-    protected _flush(done: () => void): void;
+    _init(autoStart: boolean): void;
+    _begin(done: () => void): void;
+    _read(count: number, done: () => void): void;
+    _push(item: T): void;
+    _fillBuffer(): void;
+    _completeClose(): void;
+    _flush(done: () => void): void;
 
     constructor(options?: BufferedIteratorOptions);
 }
@@ -112,12 +112,12 @@ export interface TransformIteratorOptions<S> extends BufferedIteratorOptions {
 }
 
 export class TransformIterator<S, T> extends BufferedIterator<T> {
-    protected _optional: boolean;
+    _optional: boolean;
     source: AsyncIterator<S>;
 
-    protected _validateSource(source: AsyncIterator<S>, allowDestination?: boolean): void;
-    protected _transform(item: S, done: (result: T) => void): void;
-    protected _closeWhenDone(): void;
+    _validateSource(source: AsyncIterator<S>, allowDestination?: boolean): void;
+    _transform(item: S, done: (result: T) => void): void;
+    _closeWhenDone(): void;
 
     constructor(source?: AsyncIterator<S> | TransformIteratorOptions<S>, options?: TransformIteratorOptions<S>);
 }
@@ -134,16 +134,16 @@ export interface SimpleTransformIteratorOptions<S, T> extends TransformIteratorO
 }
 
 export class SimpleTransformIterator<S, T> extends TransformIterator<S, T> {
-    protected _offset: number;
-    protected _limit: number;
-    protected _prepender?: ArrayIterator<T>;
-    protected _appender?: ArrayIterator<T>;
+    _offset: number;
+    _limit: number;
+    _prepender?: ArrayIterator<T>;
+    _appender?: ArrayIterator<T>;
 
-    protected _filter?(item: S): boolean;
-    protected _map?(item: S): T;
-    protected _transform(item: S, done: (result: T) => void): void;
+    _filter?(item: S): boolean;
+    _map?(item: S): T;
+    _transform(item: S, done: (result: T) => void): void;
 
-    protected _insert(inserter: AsyncIterator<S>, done: () => void): void;
+    _insert(inserter: AsyncIterator<S>, done: () => void): void;
 
     constructor(source?: AsyncIterator<S> | SimpleTransformIteratorOptions<S, T>,
                 options?: SimpleTransformIteratorOptions<S, T>);
@@ -152,7 +152,7 @@ export class SimpleTransformIterator<S, T> extends TransformIterator<S, T> {
 export class MultiTransformIterator<S, T> extends TransformIterator<S, T> {
     _transformerQueue: S[];
 
-    protected _createTransformer(element: S): AsyncIterator<T>;
+    _createTransformer(element: S): AsyncIterator<T>;
 
     constructor(source?: AsyncIterator<S> | TransformIteratorOptions<S>, options?: TransformIteratorOptions<S>);
 }