/// <reference types="node" />
import { EventEmitter } from 'events';
import EventSource, { EventSourceInitDict } from 'eventsource';
import type MediaWikiRevisionCreateEvent from './streams/MediaWikiRevisionCreateEvent';
import type MediaWikiPageDeleteEvent from './streams/MediaWikiPageDeleteEvent';
import type MediaWikiPageLinksChangeEvent from './streams/MediaWikiPageLinksChangeEvent';
import type MediaWikiPageMoveEvent from './streams/MediaWikiPageMoveEvent';
import type MediaWikiPagePropertiesChangeEvent from './streams/MediaWikiPagePropertiesChangeEvent';
import type MediaWikiPageUndeleteEvent from './streams/MediaWikiPageUndeleteEvent';
import type MediaWikiRecentChangeEvent from './streams/MediaWikiRecentChangeEvent';
import type MediaWikiRevisionVisibilityChangeEvent from './streams/MediaWikiRevisionVisibilityChangeEvent';
import type EventGateTestEvent from './streams/EventGateTestEvent';
import MediaWikiRevisionTagsChangeEvent from './streams/MediaWikiRevisionTagsChangeEvent';
import { WikimediaStreamFilter } from './WikimediaStreamFilter';
/**
 * The list of Wikimedia EventStreams types, excluding aliases (found in
 * {@link WikimediaEventStreamAliases} instead).
 *
 * @see {@link https://stream.wikimedia.org/?doc|List of streams}
 */
export declare const WikimediaEventStreams: readonly ["eventgate-main.test.event", "mediawiki.page-create", "mediawiki.page-delete", "mediawiki.page-links-change", "mediawiki.page-move", "mediawiki.page-properties-change", "mediawiki.page-undelete", "mediawiki.recentchange", "mediawiki.revision-create", "mediawiki.revision-tags-change", "mediawiki.revision-visibility-change"];
/**
 * The list of Wikimedia EventStreams aliases. These streams point to other
 * streams.
 *
 * @see {@link https://stream.wikimedia.org/?doc|List of streams}
 */
export declare const WikimediaEventStreamAliases: {
    readonly 'page-create': "mediawiki.page-create";
    readonly 'page-delete': "mediawiki.page-delete";
    readonly 'page-links-change': "mediawiki.page-links-change";
    readonly 'page-move': "mediawiki.page-move";
    readonly 'page-properties-change': "mediawiki.page-properties-change";
    readonly 'page-undelete': "mediawiki.page-undelete";
    readonly recentchange: "mediawiki.recentchange";
    readonly 'revision-create': "mediawiki.revision-create";
    readonly test: "eventgate-main.test.event";
};
/**
 * Type definition for each event stream. Respective type declarations for the
 * event stream payloads can be found in their respective files.
 */
export type WikimediaEventStreamEventTypes = {
    'eventgate-main.test.event': EventGateTestEvent;
    'test': EventGateTestEvent;
    'mediawiki.page-create': MediaWikiRevisionCreateEvent;
    'page-create': MediaWikiRevisionCreateEvent;
    'mediawiki.page-delete': MediaWikiPageDeleteEvent;
    'page-delete': MediaWikiPageDeleteEvent;
    'mediawiki.page-links-change': MediaWikiPageLinksChangeEvent;
    'page-links-change': MediaWikiPageLinksChangeEvent;
    'mediawiki.page-move': MediaWikiPageMoveEvent;
    'page-move': MediaWikiPageMoveEvent;
    'mediawiki.page-properties-change': MediaWikiPagePropertiesChangeEvent;
    'page-properties-change': MediaWikiPagePropertiesChangeEvent;
    'mediawiki.page-undelete': MediaWikiPageUndeleteEvent;
    'page-undelete': MediaWikiPageUndeleteEvent;
    'mediawiki.recentchange': MediaWikiRecentChangeEvent;
    'recentchange': MediaWikiRecentChangeEvent;
    'mediawiki.revision-create': MediaWikiRevisionCreateEvent;
    'revision-create': MediaWikiRevisionCreateEvent;
    'mediawiki.revision-tags-change': MediaWikiRevisionTagsChangeEvent;
    'mediawiki.revision-visibility-change': MediaWikiRevisionVisibilityChangeEvent;
};
/**
 * The ID of a non-alias Wikimedia event stream.
 */
export type SpecificWikimediaEventStream = typeof WikimediaEventStreams[number];
/**
 * The ID of an alias Wikimedia event stream.
 */
export type AliasWikimediaEventStream = keyof typeof WikimediaEventStreamAliases;
/**
 * The ID of a Wikimedia event stream.
 */
export type WikimediaEventStream = SpecificWikimediaEventStream | AliasWikimediaEventStream;
/**
 * An object mapping specific Wikimedia event streams to an array of all their aliases.
 *
 * @example `{ "mediawiki.page-create": ["page-create"], ... }`
 */
export declare const WikimediaEventStreamAliasesKey: Partial<Record<SpecificWikimediaEventStream, AliasWikimediaEventStream[]>>;
export declare enum EventSourceState {
    Pending = -1,
    Connecting = 0,
    Open = 1,
    Closed = 2
}
/**
 * Sets the type for listeners that are added to the {@link WikimediaStream} EventEmitter.
 */
export type WikimediaStreamEventListener<T extends keyof WikimediaEventStreamEventTypes> = (data: WikimediaEventStreamEventTypes[T], event: MessageEvent) => void;
/**
 * Sets the type for listeners that are added to the {@link WikimediaStream} EventEmitter.
 */
export type RawWikimediaStreamEventListener<T extends WikimediaEventStreamEventTypes[keyof WikimediaEventStreamEventTypes]> = (data: T, event: MessageEvent) => void;
export type WikimediaStreamLastEventID = {
    /**
     * The Kafka topic of the stream. This usually includes the datacenter and the
     * stream topic (e.g. `eqiad.mediawiki.recentchange`).
     */
    topic: string;
    /**
     * The Kafka partition of the stream.
     */
    partition: number;
    /**
     * The timestamp to begin enumerating from. This should be a JavaScript-like
     * timestamp (millisecond-based).
     *
     * KafkaSSE will always provide either a timestamp or an offset.
     */
    timestamp?: number;
    /**
     * The event offset to begin enumerating from.
     *
     * KafkaSSE will always provide either a timestamp or an offset.
     */
    offset?: number;
};
export interface WikimediaStreamOptions extends EventSourceInitDict {
    /**
     * Whether the stream should automatically be reopened if it closes due to an
     * error or a periodic disconnect (standard for Wikimedia Foundation streams).
     *
     * @default true
     */
    reopenOnClose?: boolean;
    /**
     * Specifies the Kafka topics, partitions and offsets from which to begin
     * streaming. You may not specify topics that are not configured to be part
     * of this stream endpoint.
     *
     * If a timestamp is given, the stream will start from an event closest
     * to the timestamp provided. If an offset is provided, the stream will start
     * from the exact event at the provided offset. If both are provided, offset
     * takes precedence.
     *
     * The last event ID received by the stream will always take precedence. If
     * you want to continue a stream with a custom last event ID after this stream
     * has already received events, instantiate a new stream.
     *
     * @see https://github.com/wikimedia/kafkasse#readme
     * @example `[{topic: datacenter1.topic, partition: 0, offset: 12345}, ...]`
     */
    lastEventId?: WikimediaStreamLastEventID[];
    /**
     * If given, this timestamp will be used as the historical starting position
     * in each the requested streams. since should either be an integer UTC
     * milliseconds unix epoch timestamp, or a string timestamp parseable by
     * `Date.parse()`. If the timestamp given does not have any corresponding offsets,
     * it will be ignored, and the data will begin streaming from the latest position
     * in the stream. This parameter is ignored if `Last-Event-ID` is set with
     * offsets (or timestamps) for individual topic partition assignments, e.g.
     * when resuming after a disconnect.
     *
     * NOTE: Historical timestamp assignment is not supported indefinitely. Depending
     * on backend stream configuration, will likely be only one or a few weeks.
     */
    since?: string;
    /**
     * Whether to start after instantiation or not.
     *
     * @default true
     */
    autoStart?: boolean;
    /**
     * Enable listening to canary events. Canary events are sent multiple times
     * an hour to ensure that streams are not broken. They are filtered by
     * default to avoid "fake" events from being received by a client.
     *
     * @see https://w.wiki/7$2z EventStreams documentation on canary events
     * @see https://w.wiki/7$2v Technical documentation on canary events
     * @default false
     */
    enableCanary?: boolean;
}
export type ErrorEvent = Event & {
    type: 'error';
    message: string | undefined;
};
export declare interface WikimediaStream {
    once<T extends keyof WikimediaEventStreamEventTypes>(event: T, listener: WikimediaStreamEventListener<T>): this;
    once(event: 'open' | 'close', listener: () => void): this;
    once(event: 'error', listener: (error: ErrorEvent) => void): this;
    on<T extends keyof WikimediaEventStreamEventTypes>(event: T, listener: WikimediaStreamEventListener<T>): this;
    on(event: 'open' | 'close', listener: () => void): this;
    on(event: 'error', listener: (error: ErrorEvent) => void): this;
    addListener<T extends keyof WikimediaEventStreamEventTypes>(event: T, listener: WikimediaStreamEventListener<T>): this;
    addListener(event: 'open' | 'close', listener: () => void): this;
    addListener(event: 'error', listener: (error: ErrorEvent) => void): this;
    off<T extends keyof WikimediaEventStreamEventTypes>(event: T, listener: WikimediaStreamEventListener<T>): this;
    off(event: 'open' | 'close', listener: () => void): this;
    off(event: 'error', listener: (error: ErrorEvent) => void): this;
    removeListener<T extends keyof WikimediaEventStreamEventTypes>(event: T, listener: WikimediaStreamEventListener<T>): this;
    removeListener(event: 'open' | 'close', listener: () => void): this;
    removeListener(event: 'error', listener: (error: ErrorEvent) => void): this;
    removeAllListeners(event?: 'open' | 'error' | 'close' | WikimediaEventStream): this;
    listeners(event: 'open' | 'error' | 'close' | WikimediaEventStream): Function[];
    rawListeners(event: 'open' | 'error' | 'close' | WikimediaEventStream): Function[];
    emit<T extends keyof WikimediaEventStreamEventTypes>(eventName: T, data: WikimediaEventStreamEventTypes[T], event: MessageEvent): boolean;
    emit(event: 'open' | 'close'): this;
    emit(event: 'error', error: ErrorEvent): this;
    listenerCount(event: 'open' | 'error' | 'close' | WikimediaEventStream): number;
    prependListener<T extends keyof WikimediaEventStreamEventTypes>(event: T, listener: WikimediaStreamEventListener<T>): this;
    prependListener(event: 'open' | 'close', listener: () => void): this;
    prependListener(event: 'error', listener: (error: ErrorEvent) => void): this;
    prependOnceListener<T extends keyof WikimediaEventStreamEventTypes>(event: T, listener: WikimediaStreamEventListener<T>): this;
    prependOnceListener(event: 'open' | 'close', listener: () => void): this;
    prependOnceListener(event: 'error', listener: (error: ErrorEvent) => void): this;
}
/**
 * A WikimediaStream connects to the Wikimedia Event Platform EventStreams
 * domain (found at {@link https://streams.wikimedia.org}) and provides real-time
 * recent changes and actions on Wikimedia wikis.
 */
export declare class WikimediaStream extends EventEmitter {
    /**
     * The EventSource which listens to streams on the Wikimedia Event Platform. Uses
     * the `eventsource` package, which is backwards-compatible with the
     * {@link https://developer.mozilla.org/en-US/docs/Web/API/EventSource|EventSource} Web API.
     */
    eventSource: EventSource;
    /**
     * The last event ID received from the EventSource. Used to seamlessly re-listen to
     * closed connections.
     *
     * @private
     */
    private _lastEventId;
    /**
     * The streams that this WikimediaStream is currently listening/will listen to.
     *
     * @private
     */
    private readonly streams;
    /**
     * A NodeJS.Timeout which checks if the EventSource is still open. The interval
     * checks if the EventSource is still open every second, and reopens it if it's
     * closed.
     *
     * @private
     */
    private openCheckInterval;
    /**
     * A NodeJS.Timeout which reopens the EventSource every 15 minutes. This ensures
     * that messages are still being received (with a worst possible lag of 15 minutes)
     * even if the EventSource disconnects with no error or close event.
     *
     * @private
     */
    private restartInterval;
    /**
     * The current status of this stream.
     */
    get status(): EventSourceState;
    get lastEventId(): WikimediaStreamLastEventID[];
    /**
     * The version of this package. Used for the default `User-Agent` header.
     */
    static readonly VERSION = "3.0.0";
    /**
     * The generic user agent to be used by wikimedia-streams when
     * no default user agent is used or set.
     */
    static readonly genericUserAgent: string;
    /**
     * The default user agent to be used by wikimedia-streams.
     */
    static defaultUserAgent: string;
    /**
     * Checks if a given string is a valid {@link WikimediaEventStream}.
     *
     * @param stream The string to check.
     * @return {} Whether the stream is a valid Wikimedia stream ID or not.
     */
    static isWikimediaStream(stream: string): stream is SpecificWikimediaEventStream;
    /**
     * Checks if a given string is a valid {@link AliasWikimediaEventStream} ID.
     *
     * @param stream The string to check.
     */
    static isWikimediaStreamAlias(stream: WikimediaEventStream): stream is AliasWikimediaEventStream;
    /**
     * Checks if a given string is a valid {@link SpecificWikimediaEventStream} ID.
     *
     * @param stream The string to check.
     */
    static isSpecificWikimediaStream(stream: WikimediaEventStream): stream is SpecificWikimediaEventStream;
    private readonly startingOptions;
    /**
     * Creates a new Wikimedia RecentChanges listener. This will automatically start the
     * stream upon construction; you do not need to call {@link WikimediaStream#open} after
     * instantiating this class.
     *
     * @param streams
     *   The streams to listen to. You may choose any stream defined by the
     *   {@link https://stream.wikimedia.org/?doc|Wikimedia EventStreams documentation page}.
     * @param options
     *   Additional options for the EventSource.
     */
    constructor(streams: WikimediaEventStream | WikimediaEventStream[], options?: WikimediaStreamOptions);
    /**
     * Start listening to the stream.
     *
     * @param options
     *   Additional options for the EventSource.
     * @return A Promise that resolves once the stream is open.
     */
    open(options?: Omit<WikimediaStreamOptions, 'autoStart'>): Promise<void>;
    /**
     * Stop listening to the stream.
     */
    close(): void;
    /**
     * @param options
     */
    attachEventListeners(options: WikimediaStreamOptions): void;
    /**
     *
     */
    eventNames(): ('open' | 'error' | 'close' | WikimediaEventStream)[];
    filter<T extends WikimediaEventStream>(eventType: T): WikimediaStreamFilter<WikimediaEventStreamEventTypes[T], T>;
    /**
     * Returns a promise that resolves when the stream is closed.
     */
    waitUntilClosed(): Promise<void>;
}
export default WikimediaStream;