1import { Observable } from '../Observable';
2import { Subscriber } from '../Subscriber';
3import { OuterSubscriber } from '../OuterSubscriber';
4import { InnerSubscriber } from '../InnerSubscriber';
5import { MonoTypeOperatorFunction } from '../types';
6/**
7 * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.
8 *
9 * If a keySelector function is provided, then it will project each value from the source observable into a new value that it will
10 * check for equality with previously projected values. If a keySelector function is not provided, it will use each value from the
11 * source observable directly with an equality check against previous values.
12 *
13 * In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking.
14 *
15 * In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the
16 * hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct`
17 * use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so
18 * that the internal `Set` can be "flushed", basically clearing it of values.
19 *
20 * ## Examples
21 * A simple example with numbers
22 * ```ts
23 * import { of } from 'rxjs';
24 * import { distinct } from 'rxjs/operators';
25 *
26 * of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1).pipe(
27 *     distinct(),
28 *   )
29 *   .subscribe(x => console.log(x)); // 1, 2, 3, 4
30 * ```
31 *
32 * An example using a keySelector function
33 * ```typescript
34 * import { of } from 'rxjs';
35 * import { distinct } from 'rxjs/operators';
36 *
37 * interface Person {
38 *    age: number,
39 *    name: string
40 * }
41 *
42 * of<Person>(
43 *     { age: 4, name: 'Foo'},
44 *     { age: 7, name: 'Bar'},
45 *     { age: 5, name: 'Foo'},
46 *   ).pipe(
47 *     distinct((p: Person) => p.name),
48 *   )
49 *   .subscribe(x => console.log(x));
50 *
51 * // displays:
52 * // { age: 4, name: 'Foo' }
53 * // { age: 7, name: 'Bar' }
54 * ```
55 * @see {@link distinctUntilChanged}
56 * @see {@link distinctUntilKeyChanged}
57 *
58 * @param {function} [keySelector] Optional function to select which value you want to check as distinct.
59 * @param {Observable} [flushes] Optional Observable for flushing the internal HashSet of the operator.
60 * @return {Observable} An Observable that emits items from the source Observable with distinct values.
61 * @method distinct
62 * @owner Observable
63 */
64export declare function distinct<T, K>(keySelector?: (value: T) => K, flushes?: Observable<any>): MonoTypeOperatorFunction<T>;
65/**
66 * We need this JSDoc comment for affecting ESDoc.
67 * @ignore
68 * @extends {Ignored}
69 */
70export declare class DistinctSubscriber<T, K> extends OuterSubscriber<T, T> {
71    private keySelector;
72    private values;
73    constructor(destination: Subscriber<T>, keySelector: (value: T) => K, flushes: Observable<any>);
74    notifyNext(outerValue: T, innerValue: T, outerIndex: number, innerIndex: number, innerSub: InnerSubscriber<T, T>): void;
75    notifyError(error: any, innerSub: InnerSubscriber<T, T>): void;
76    protected _next(value: T): void;
77    private _useKeySelector;
78    private _finalizeNext;
79}
80