@types/rx-lite-aggregates

  • Version 4.0.3
  • Published
  • 1 dependency
  • MIT license

Install

npm i @types/rx-lite-aggregates
yarn add @types/rx-lite-aggregates
pnpm add @types/rx-lite-aggregates

Overview

TypeScript definitions for rx-lite-aggregates

Index

Namespaces

namespace Rx

namespace Rx {}

    interface Observable

    interface Observable<T> {}

      method aggregate

      aggregate: {
      (accumulator: (acc: T, value: T) => T): Observable<T>;
      <TAcc>(
      seed: TAcc,
      accumulator: (acc: TAcc, value: T) => TAcc
      ): Observable<TAcc>;
      };

        method all

        all: (predicate?: (value: T) => boolean, thisArg?: any) => Observable<boolean>;

          method any

          any: (
          predicate?: (value: T, index: number, source: Observable<T>) => boolean,
          thisArg?: any
          ) => Observable<boolean>;

            method average

            average: (
            keySelector?: (value: T, index: number, source: Observable<T>) => number,
            thisArg?: any
            ) => Observable<number>;

              method contains

              contains: {
              (value: T): Observable<boolean>;
              <TOther>(
              value: TOther,
              comparer: (value1: T, value2: TOther) => boolean
              ): Observable<boolean>;
              };

                method count

                count: (
                predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                thisArg?: any
                ) => Observable<number>;

                  method elementAt

                  elementAt: (index: number) => Observable<T>;

                    method every

                    every: (predicate?: (value: T) => boolean, thisArg?: any) => Observable<boolean>;

                      method finalValue

                      finalValue: () => Observable<T>;

                        method find

                        find: (
                        predicate: (value: T, index: number, source: Observable<T>) => boolean,
                        thisArg?: any
                        ) => Observable<T>;

                          method findIndex

                          findIndex: (
                          predicate: (value: T, index: number, source: Observable<T>) => boolean,
                          thisArg?: any
                          ) => Observable<number>;

                            method first

                            first: (
                            predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                            thisArg?: any
                            ) => Observable<T>;

                              method isEmpty

                              isEmpty: () => Observable<boolean>;

                                method last

                                last: (
                                predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                thisArg?: any
                                ) => Observable<T>;

                                  method max

                                  max: (comparer?: (value1: T, value2: T) => number) => Observable<number>;

                                    method maxBy

                                    maxBy: {
                                    <TKey>(
                                    keySelector: (item: T) => TKey,
                                    comparer: (value1: TKey, value2: TKey) => number
                                    ): Observable<T>;
                                    (keySelector: (item: T) => number): Observable<T>;
                                    };

                                      method min

                                      min: (comparer?: (value1: T, value2: T) => number) => Observable<T>;

                                        method minBy

                                        minBy: {
                                        <TKey>(
                                        keySelector: (item: T) => TKey,
                                        comparer: (value1: TKey, value2: TKey) => number
                                        ): Observable<T>;
                                        (keySelector: (item: T) => number): Observable<T>;
                                        };

                                          method reduce

                                          reduce: {
                                          (accumulator: (acc: T, value: T) => T): Observable<T>;
                                          <TAcc>(
                                          accumulator: (acc: TAcc, value: T) => TAcc,
                                          seed: TAcc
                                          ): Observable<TAcc>;
                                          };

                                            method sequenceEqual

                                            sequenceEqual: {
                                            <TOther>(
                                            second: Observable<TOther>,
                                            comparer: (value1: T, value2: TOther) => number
                                            ): Observable<boolean>;
                                            <TOther>(
                                            second: any,
                                            comparer: (value1: T, value2: TOther) => number
                                            ): Observable<boolean>;
                                            (second: Observable<T>): Observable<boolean>;
                                            (second: any): Observable<boolean>;
                                            <TOther>(
                                            second: TOther[],
                                            comparer: (value1: T, value2: TOther) => number
                                            ): Observable<boolean>;
                                            (second: T[]): Observable<boolean>;
                                            };

                                              method single

                                              single: (
                                              predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                              thisArg?: any
                                              ) => Observable<T>;

                                                method some

                                                some: (
                                                predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                                thisArg?: any
                                                ) => Observable<boolean>;

                                                  method sum

                                                  sum: (
                                                  keySelector?: (value: T, index: number, source: Observable<T>) => number,
                                                  thisArg?: any
                                                  ) => Observable<number>;

                                                    namespace rx-lite-aggregates

                                                    module 'rx-lite-aggregates' {}

                                                      interface Observable

                                                      interface Observable<T> {}

                                                        method aggregate

                                                        aggregate: {
                                                        (accumulator: (acc: T, value: T) => T): Observable<T>;
                                                        <TAcc>(
                                                        seed: TAcc,
                                                        accumulator: (acc: TAcc, value: T) => TAcc
                                                        ): Observable<TAcc>;
                                                        };

                                                          method all

                                                          all: (predicate?: (value: T) => boolean, thisArg?: any) => Observable<boolean>;

                                                            method any

                                                            any: (
                                                            predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                                            thisArg?: any
                                                            ) => Observable<boolean>;

                                                              method average

                                                              average: (
                                                              keySelector?: (value: T, index: number, source: Observable<T>) => number,
                                                              thisArg?: any
                                                              ) => Observable<number>;

                                                                method contains

                                                                contains: {
                                                                (value: T): Observable<boolean>;
                                                                <TOther>(
                                                                value: TOther,
                                                                comparer: (value1: T, value2: TOther) => boolean
                                                                ): Observable<boolean>;
                                                                };

                                                                  method count

                                                                  count: (
                                                                  predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                                                  thisArg?: any
                                                                  ) => Observable<number>;

                                                                    method elementAt

                                                                    elementAt: (index: number) => Observable<T>;

                                                                      method every

                                                                      every: (predicate?: (value: T) => boolean, thisArg?: any) => Observable<boolean>;

                                                                        method finalValue

                                                                        finalValue: () => Observable<T>;

                                                                          method find

                                                                          find: (
                                                                          predicate: (value: T, index: number, source: Observable<T>) => boolean,
                                                                          thisArg?: any
                                                                          ) => Observable<T>;

                                                                            method findIndex

                                                                            findIndex: (
                                                                            predicate: (value: T, index: number, source: Observable<T>) => boolean,
                                                                            thisArg?: any
                                                                            ) => Observable<number>;

                                                                              method first

                                                                              first: (
                                                                              predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                                                              thisArg?: any
                                                                              ) => Observable<T>;

                                                                                method isEmpty

                                                                                isEmpty: () => Observable<boolean>;

                                                                                  method last

                                                                                  last: (
                                                                                  predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                                                                  thisArg?: any
                                                                                  ) => Observable<T>;

                                                                                    method max

                                                                                    max: (comparer?: (value1: T, value2: T) => number) => Observable<number>;

                                                                                      method maxBy

                                                                                      maxBy: {
                                                                                      <TKey>(
                                                                                      keySelector: (item: T) => TKey,
                                                                                      comparer: (value1: TKey, value2: TKey) => number
                                                                                      ): Observable<T>;
                                                                                      (keySelector: (item: T) => number): Observable<T>;
                                                                                      };

                                                                                        method min

                                                                                        min: (comparer?: (value1: T, value2: T) => number) => Observable<T>;

                                                                                          method minBy

                                                                                          minBy: {
                                                                                          <TKey>(
                                                                                          keySelector: (item: T) => TKey,
                                                                                          comparer: (value1: TKey, value2: TKey) => number
                                                                                          ): Observable<T>;
                                                                                          (keySelector: (item: T) => number): Observable<T>;
                                                                                          };

                                                                                            method reduce

                                                                                            reduce: {
                                                                                            (accumulator: (acc: T, value: T) => T): Observable<T>;
                                                                                            <TAcc>(
                                                                                            accumulator: (acc: TAcc, value: T) => TAcc,
                                                                                            seed: TAcc
                                                                                            ): Observable<TAcc>;
                                                                                            };

                                                                                              method sequenceEqual

                                                                                              sequenceEqual: {
                                                                                              <TOther>(
                                                                                              second: Observable<TOther>,
                                                                                              comparer: (value1: T, value2: TOther) => number
                                                                                              ): Observable<boolean>;
                                                                                              <TOther>(
                                                                                              second: any,
                                                                                              comparer: (value1: T, value2: TOther) => number
                                                                                              ): Observable<boolean>;
                                                                                              (second: Observable<T>): Observable<boolean>;
                                                                                              (second: any): Observable<boolean>;
                                                                                              <TOther>(
                                                                                              second: TOther[],
                                                                                              comparer: (value1: T, value2: TOther) => number
                                                                                              ): Observable<boolean>;
                                                                                              (second: T[]): Observable<boolean>;
                                                                                              };

                                                                                                method single

                                                                                                single: (
                                                                                                predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                                                                                thisArg?: any
                                                                                                ) => Observable<T>;

                                                                                                  method some

                                                                                                  some: (
                                                                                                  predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                                                                                                  thisArg?: any
                                                                                                  ) => Observable<boolean>;

                                                                                                    method sum

                                                                                                    sum: (
                                                                                                    keySelector?: (value: T, index: number, source: Observable<T>) => number,
                                                                                                    thisArg?: any
                                                                                                    ) => Observable<number>;

                                                                                                      Package Files (1)

                                                                                                      Dependencies (1)

                                                                                                      Dev Dependencies (0)

                                                                                                      No dev dependencies.

                                                                                                      Peer Dependencies (0)

                                                                                                      No peer dependencies.

                                                                                                      Badge

                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/rx-lite-aggregates.

                                                                                                      • Markdown
                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/rx-lite-aggregates)
                                                                                                      • HTML
                                                                                                        <a href="https://www.jsdocs.io/package/@types/rx-lite-aggregates"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>