404

[ Avaa Bypassed ]




Upload:

Command:

botdev@18.217.203.133: ~ $
import { Operator } from './Operator';
import { Subscriber } from './Subscriber';
import { Subscription } from './Subscription';
import { TeardownLogic, OperatorFunction, PartialObserver, Subscribable } from './types';
import { iif } from './observable/iif';
import { throwError } from './observable/throwError';
/**
 * A representation of any set of values over any amount of time. This is the most basic building block
 * of RxJS.
 *
 * @class Observable<T>
 */
export declare class Observable<T> implements Subscribable<T> {
    /** Internal implementation detail, do not use directly. */
    _isScalar: boolean;
    /** @deprecated This is an internal implementation detail, do not use. */
    source: Observable<any>;
    /** @deprecated This is an internal implementation detail, do not use. */
    operator: Operator<any, T>;
    /**
     * @constructor
     * @param {Function} subscribe the function that is called when the Observable is
     * initially subscribed to. This function is given a Subscriber, to which new values
     * can be `next`ed, or an `error` method can be called to raise an error, or
     * `complete` can be called to notify of a successful completion.
     */
    constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
    /**
     * Creates a new cold Observable by calling the Observable constructor
     * @static true
     * @owner Observable
     * @method create
     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
     * @return {Observable} a new cold observable
     * @nocollapse
     * @deprecated use new Observable() instead
     */
    static create: Function;
    /**
     * Creates a new Observable, with this Observable as the source, and the passed
     * operator defined as the new observable's operator.
     * @method lift
     * @param {Operator} operator the operator defining the operation to take on the observable
     * @return {Observable} a new observable with the Operator applied
     */
    lift<R>(operator: Operator<T, R>): Observable<R>;
    subscribe(observer?: PartialObserver<T>): Subscription;
    /** @deprecated Use an observer instead of a complete callback */
    subscribe(next: null | undefined, error: null | undefined, complete: () => void): Subscription;
    /** @deprecated Use an observer instead of an error callback */
    subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Subscription;
    /** @deprecated Use an observer instead of a complete callback */
    subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Subscription;
    subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
    /** @deprecated This is an internal implementation detail, do not use. */
    _trySubscribe(sink: Subscriber<T>): TeardownLogic;
    /**
     * @method forEach
     * @param {Function} next a handler for each value emitted by the observable
     * @param {PromiseConstructor} [promiseCtor] a constructor function used to instantiate the Promise
     * @return {Promise} a promise that either resolves on observable completion or
     *  rejects with the handled error
     */
    forEach(next: (value: T) => void, promiseCtor?: PromiseConstructorLike): Promise<void>;
    /** @internal This is an internal implementation detail, do not use. */
    _subscribe(subscriber: Subscriber<any>): TeardownLogic;
    /**
     * @nocollapse
     * @deprecated In favor of iif creation function: import { iif } from 'rxjs';
     */
    static if: typeof iif;
    /**
     * @nocollapse
     * @deprecated In favor of throwError creation function: import { throwError } from 'rxjs';
     */
    static throw: typeof throwError;
    pipe(): Observable<T>;
    pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
    pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
    pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
    pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
    pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
    pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
    pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
    pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<{}>;
    toPromise<T>(this: Observable<T>): Promise<T>;
    toPromise<T>(this: Observable<T>, PromiseCtor: typeof Promise): Promise<T>;
    toPromise<T>(this: Observable<T>, PromiseCtor: PromiseConstructorLike): Promise<T>;
}

Filemanager

Name Type Size Permission Actions
observable Folder 0755
operators Folder 0755
scheduled Folder 0755
scheduler Folder 0755
symbol Folder 0755
testing Folder 0755
util Folder 0755
AsyncSubject.d.ts File 640 B 0644
AsyncSubject.js File 2.17 KB 0644
AsyncSubject.js.map File 1.11 KB 0644
BehaviorSubject.d.ts File 597 B 0644
BehaviorSubject.js File 2.01 KB 0644
BehaviorSubject.js.map File 894 B 0644
InnerSubscriber.d.ts File 532 B 0644
InnerSubscriber.js File 1.59 KB 0644
InnerSubscriber.js.map File 801 B 0644
Notification.d.ts File 3.37 KB 0644
Notification.js File 2.72 KB 0644
Notification.js.map File 2.09 KB 0644
Observable.d.ts File 5.93 KB 0644
Observable.js File 3.96 KB 0644
Observable.js.map File 2.98 KB 0644
Observer.d.ts File 79 B 0644
Observer.js File 523 B 0644
Observer.js.map File 380 B 0644
Operator.d.ts File 185 B 0644
Operator.js File 113 B 0644
Operator.js.map File 102 B 0644
OuterSubscriber.d.ts File 509 B 0644
OuterSubscriber.js File 1.41 KB 0644
OuterSubscriber.js.map File 543 B 0644
ReplaySubject.d.ts File 982 B 0644
ReplaySubject.js File 4.84 KB 0644
ReplaySubject.js.map File 3.4 KB 0644
Rx.d.ts File 8.91 KB 0644
Rx.js File 9.22 KB 0644
Rx.js.map File 2.86 KB 0644
Scheduler.d.ts File 2.4 KB 0644
Scheduler.js File 633 B 0644
Scheduler.js.map File 537 B 0644
Subject.d.ts File 2.19 KB 0644
Subject.js File 5.9 KB 0644
Subject.js.map File 3.82 KB 0644
SubjectSubscription.d.ts File 444 B 0644
SubjectSubscription.js File 1.7 KB 0644
SubjectSubscription.js.map File 863 B 0644
Subscriber.d.ts File 3.67 KB 0644
Subscriber.js File 9.04 KB 0644
Subscriber.js.map File 5.86 KB 0644
Subscription.d.ts File 2.72 KB 0644
Subscription.js File 5.18 KB 0644
Subscription.js.map File 3.75 KB 0644
config.d.ts File 860 B 0644
config.js File 846 B 0644
config.js.map File 502 B 0644
innerSubscribe.d.ts File 2.4 KB 0644
innerSubscribe.js File 4.14 KB 0644
innerSubscribe.js.map File 2.15 KB 0644
types.d.ts File 3.17 KB 0644
types.js File 110 B 0644
types.js.map File 96 B 0644