///
import { EventEmitter } from 'events';
import { Stream, InternalProducer, InternalListener } from '../index';
export declare class DOMEventProducer implements InternalProducer {
private node;
private eventType;
private useCapture;
type: string;
private listener;
constructor(node: EventTarget, eventType: string, useCapture: boolean);
_start(out: InternalListener): void;
_stop(): void;
}
export declare class NodeEventProducer implements InternalProducer {
private node;
private eventName;
type: string;
private listener;
constructor(node: EventEmitter, eventName: string);
_start(out: InternalListener): void;
_stop(): void;
}
/**
* Creates a stream based on either:
* - DOM events with the name `eventName` from a provided target node
* - Events with the name `eventName` from a provided NodeJS EventEmitter
*
* When creating a stream from EventEmitters, if the source event has more than
* one argument all the arguments will be aggregated into an array in the
* result stream.
*
* (Tip: when using this factory with TypeScript, you will need types for
* Node.js because fromEvent knows how to handle both DOM events and Node.js
* EventEmitter. Just install `@types/node`)
*
* Marble diagram:
*
* ```text
* fromEvent(element, eventName)
* ---ev--ev----ev---------------
* ```
*
* Examples:
*
* ```js
* import fromEvent from 'xstream/extra/fromEvent'
*
* const stream = fromEvent(document.querySelector('.button'), 'click')
* .mapTo('Button clicked!')
*
* stream.addListener({
* next: i => console.log(i),
* error: err => console.error(err),
* complete: () => console.log('completed')
* })
* ```
*
* ```text
* > 'Button clicked!'
* > 'Button clicked!'
* > 'Button clicked!'
* ```
*
* ```js
* import fromEvent from 'xstream/extra/fromEvent'
* import {EventEmitter} from 'events'
*
* const MyEmitter = new EventEmitter()
* const stream = fromEvent(MyEmitter, 'foo')
*
* stream.addListener({
* next: i => console.log(i),
* error: err => console.error(err),
* complete: () => console.log('completed')
* })
*
* MyEmitter.emit('foo', 'bar')
* ```
*
* ```text
* > 'bar'
* ```
*
* ```js
* import fromEvent from 'xstream/extra/fromEvent'
* import {EventEmitter} from 'events'
*
* const MyEmitter = new EventEmitter()
* const stream = fromEvent(MyEmitter, 'foo')
*
* stream.addListener({
* next: i => console.log(i),
* error: err => console.error(err),
* complete: () => console.log('completed')
* })
*
* MyEmitter.emit('foo', 'bar', 'baz', 'buzz')
* ```
*
* ```text
* > ['bar', 'baz', 'buzz']
* ```
*
* @factory true
* @param {EventTarget|EventEmitter} element The element upon which to listen.
* @param {string} eventName The name of the event for which to listen.
* @param {boolean?} useCapture An optional boolean that indicates that events of
* this type will be dispatched to the registered listener before being
* dispatched to any EventTarget beneath it in the DOM tree. Defaults to false.
* @return {Stream}
*/
export default function fromEvent(element: EventTarget | EventEmitter, eventName: string, useCapture?: boolean): Stream;