@types/rx-lite-time

  • Version 4.0.3
  • Published
  • 1 dependency
  • MIT license

Install

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

Overview

TypeScript definitions for rx-lite-time

Index

Namespaces

namespace Rx

namespace Rx {}

    interface Observable

    interface Observable<T> {}

      method bufferWithTime

      bufferWithTime: {
      (timeSpan: number, timeShift: number, scheduler?: any): Observable<T[]>;
      (timeSpan: number, scheduler?: any): Observable<T[]>;
      };

        method bufferWithTimeOrCount

        bufferWithTimeOrCount: (
        timeSpan: number,
        count: number,
        scheduler?: any
        ) => Observable<T[]>;

          method debounceWithSelector

          debounceWithSelector: <TTimeout>(
          debounceDurationSelector: (item: T) => Observable<TTimeout>
          ) => Observable<T>;

            method delaySubscription

            delaySubscription: (dueTime: number, scheduler?: any) => Observable<T>;

              method delayWithSelector

              delayWithSelector: {
              (delayDurationSelector: (item: T) => number): Observable<T>;
              (
              subscriptionDelay: number,
              delayDurationSelector: (item: T) => number
              ): Observable<T>;
              };

                method skipLastWithTime

                skipLastWithTime: (duration: number, scheduler?: any) => Observable<T>;

                  method skipUntilWithTime

                  skipUntilWithTime: {
                  (startTime: Date, scheduler?: any): Observable<T>;
                  (duration: number, scheduler?: any): Observable<T>;
                  };

                    method skipWithTime

                    skipWithTime: (duration: number, scheduler?: any) => Observable<T>;

                      method takeLastBufferWithTime

                      takeLastBufferWithTime: (duration: number, scheduler?: any) => Observable<T[]>;

                        method takeLastWithTime

                        takeLastWithTime: (
                        duration: number,
                        timerScheduler?: any,
                        loopScheduler?: any
                        ) => Observable<T>;

                          method takeUntilWithTime

                          takeUntilWithTime: {
                          (endTime: Date, scheduler?: any): Observable<T>;
                          (duration: number, scheduler?: any): Observable<T>;
                          };

                            method takeWithTime

                            takeWithTime: (duration: number, scheduler?: any) => Observable<T>;

                              method throttleWithSelector

                              throttleWithSelector: <TTimeout>(
                              debounceDurationSelector: (item: T) => Observable<TTimeout>
                              ) => Observable<T>;
                              • Deprecated

                                use #debounceWithSelector instead.

                              method timeoutWithSelector

                              timeoutWithSelector: <TTimeout>(
                              firstTimeout: Observable<TTimeout>,
                              timeoutdurationSelector?: (item: T) => Observable<TTimeout>,
                              other?: Observable<T>
                              ) => Observable<T>;

                                method windowWithTime

                                windowWithTime: {
                                (timeSpan: number, timeShift: number, scheduler?: any): Observable<
                                Observable<T>
                                >;
                                (timeSpan: number, scheduler?: any): Observable<Observable<T>>;
                                };

                                  method windowWithTimeOrCount

                                  windowWithTimeOrCount: (
                                  timeSpan: number,
                                  count: number,
                                  scheduler?: any
                                  ) => Observable<Observable<T>>;

                                    interface ObservableStatic

                                    interface ObservableStatic {}

                                      method generateWithAbsoluteTime

                                      generateWithAbsoluteTime: <TState, TResult>(
                                      initialState: TState,
                                      condition: (state: TState) => boolean,
                                      iterate: (state: TState) => TState,
                                      resultSelector: (state: TState) => TResult,
                                      timeSelector: (state: TState) => Date,
                                      scheduler?: any
                                      ) => Observable<TResult>;

                                        method generateWithRelativeTime

                                        generateWithRelativeTime: <TState, TResult>(
                                        initialState: TState,
                                        condition: (state: TState) => boolean,
                                        iterate: (state: TState) => TState,
                                        resultSelector: (state: TState) => TResult,
                                        timeSelector: (state: TState) => number,
                                        scheduler?: any
                                        ) => Observable<TResult>;

                                          method timer

                                          timer: {
                                          (dueTime: Date, period: number, scheduler?: any): Observable<number>;
                                          (dueTime: Date, scheduler?: any): Observable<number>;
                                          };

                                            namespace rx-lite-time

                                            module 'rx-lite-time' {}

                                              interface Observable

                                              interface Observable<T> {}

                                                method bufferWithTime

                                                bufferWithTime: {
                                                (timeSpan: number, timeShift: number, scheduler?: any): Observable<T[]>;
                                                (timeSpan: number, scheduler?: any): Observable<T[]>;
                                                };

                                                  method bufferWithTimeOrCount

                                                  bufferWithTimeOrCount: (
                                                  timeSpan: number,
                                                  count: number,
                                                  scheduler?: any
                                                  ) => Observable<T[]>;

                                                    method debounceWithSelector

                                                    debounceWithSelector: <TTimeout>(
                                                    debounceDurationSelector: (item: T) => Observable<TTimeout>
                                                    ) => Observable<T>;

                                                      method delaySubscription

                                                      delaySubscription: (dueTime: number, scheduler?: any) => Observable<T>;

                                                        method delayWithSelector

                                                        delayWithSelector: {
                                                        (delayDurationSelector: (item: T) => number): Observable<T>;
                                                        (
                                                        subscriptionDelay: number,
                                                        delayDurationSelector: (item: T) => number
                                                        ): Observable<T>;
                                                        };

                                                          method skipLastWithTime

                                                          skipLastWithTime: (duration: number, scheduler?: any) => Observable<T>;

                                                            method skipUntilWithTime

                                                            skipUntilWithTime: {
                                                            (startTime: Date, scheduler?: any): Observable<T>;
                                                            (duration: number, scheduler?: any): Observable<T>;
                                                            };

                                                              method skipWithTime

                                                              skipWithTime: (duration: number, scheduler?: any) => Observable<T>;

                                                                method takeLastBufferWithTime

                                                                takeLastBufferWithTime: (duration: number, scheduler?: any) => Observable<T[]>;

                                                                  method takeLastWithTime

                                                                  takeLastWithTime: (
                                                                  duration: number,
                                                                  timerScheduler?: any,
                                                                  loopScheduler?: any
                                                                  ) => Observable<T>;

                                                                    method takeUntilWithTime

                                                                    takeUntilWithTime: {
                                                                    (endTime: Date, scheduler?: any): Observable<T>;
                                                                    (duration: number, scheduler?: any): Observable<T>;
                                                                    };

                                                                      method takeWithTime

                                                                      takeWithTime: (duration: number, scheduler?: any) => Observable<T>;

                                                                        method throttleWithSelector

                                                                        throttleWithSelector: <TTimeout>(
                                                                        debounceDurationSelector: (item: T) => Observable<TTimeout>
                                                                        ) => Observable<T>;
                                                                        • Deprecated

                                                                          use #debounceWithSelector instead.

                                                                        method timeoutWithSelector

                                                                        timeoutWithSelector: <TTimeout>(
                                                                        firstTimeout: Observable<TTimeout>,
                                                                        timeoutdurationSelector?: (item: T) => Observable<TTimeout>,
                                                                        other?: Observable<T>
                                                                        ) => Observable<T>;

                                                                          method windowWithTime

                                                                          windowWithTime: {
                                                                          (timeSpan: number, timeShift: number, scheduler?: any): Observable<
                                                                          Observable<T>
                                                                          >;
                                                                          (timeSpan: number, scheduler?: any): Observable<Observable<T>>;
                                                                          };

                                                                            method windowWithTimeOrCount

                                                                            windowWithTimeOrCount: (
                                                                            timeSpan: number,
                                                                            count: number,
                                                                            scheduler?: any
                                                                            ) => Observable<Observable<T>>;

                                                                              interface ObservableStatic

                                                                              interface ObservableStatic {}

                                                                                method generateWithAbsoluteTime

                                                                                generateWithAbsoluteTime: <TState, TResult>(
                                                                                initialState: TState,
                                                                                condition: (state: TState) => boolean,
                                                                                iterate: (state: TState) => TState,
                                                                                resultSelector: (state: TState) => TResult,
                                                                                timeSelector: (state: TState) => Date,
                                                                                scheduler?: any
                                                                                ) => Observable<TResult>;

                                                                                  method generateWithRelativeTime

                                                                                  generateWithRelativeTime: <TState, TResult>(
                                                                                  initialState: TState,
                                                                                  condition: (state: TState) => boolean,
                                                                                  iterate: (state: TState) => TState,
                                                                                  resultSelector: (state: TState) => TResult,
                                                                                  timeSelector: (state: TState) => number,
                                                                                  scheduler?: any
                                                                                  ) => Observable<TResult>;

                                                                                    method timer

                                                                                    timer: {
                                                                                    (dueTime: Date, period: number, scheduler?: any): Observable<number>;
                                                                                    (dueTime: Date, scheduler?: 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-time.

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