ngxsmk-datepicker 1.2.8 → 1.3.0

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/publishLast.d.ts

@@ -1,69 +0,0 @@
-import { Observable } from '../Observable';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { UnaryFunction } from '../types';
-/**
- * Returns a connectable observable sequence that shares a single subscription to the
- * underlying sequence containing only the last notification.
- *
- * ![](publishLast.png)
- *
- * Similar to {@link publish}, but it waits until the source observable completes and stores
- * the last emitted value.
- * Similarly to {@link publishReplay} and {@link publishBehavior}, this keeps storing the last
- * value even if it has no more subscribers. If subsequent subscriptions happen, they will
- * immediately get that last stored value and complete.
- *
- * ## Example
- *
- * ```ts
- * import { ConnectableObservable, interval, publishLast, tap, take } from 'rxjs';
- *
- * const connectable = <ConnectableObservable<number>>interval(1000)
- *   .pipe(
- *     tap(x => console.log('side effect', x)),
- *     take(3),
- *     publishLast()
- *   );
- *
- * connectable.subscribe({
- *   next: x => console.log('Sub. A', x),
- *   error: err => console.log('Sub. A Error', err),
- *   complete: () => console.log('Sub. A Complete')
- * });
- *
- * connectable.subscribe({
- *   next: x => console.log('Sub. B', x),
- *   error: err => console.log('Sub. B Error', err),
- *   complete: () => console.log('Sub. B Complete')
- * });
- *
- * connectable.connect();
- *
- * // Results:
- * // 'side effect 0'   - after one second
- * // 'side effect 1'   - after two seconds
- * // 'side effect 2'   - after three seconds
- * // 'Sub. A 2'        - immediately after 'side effect 2'
- * // 'Sub. B 2'
- * // 'Sub. A Complete'
- * // 'Sub. B Complete'
- * ```
- *
- * @see {@link ConnectableObservable}
- * @see {@link publish}
- * @see {@link publishReplay}
- * @see {@link publishBehavior}
- *
- * @return A function that returns an Observable that emits elements of a
- * sequence produced by multicasting the source sequence.
- * @deprecated Will be removed in v8. To create a connectable observable with an
- * {@link AsyncSubject} under the hood, use {@link connectable}.
- * `source.pipe(publishLast())` is equivalent to
- * `connectable(source, { connector: () => new AsyncSubject(), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishLast`, use the {@link share} operator instead.
- * `source.pipe(publishLast(), refCount())` is equivalent to
- * `source.pipe(share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishLast<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-//# sourceMappingURL=publishLast.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/publishReplay.d.ts

@@ -1,56 +0,0 @@
-import { Observable } from '../Observable';
-import { MonoTypeOperatorFunction, OperatorFunction, TimestampProvider, ObservableInput, ObservedValueOf } from '../types';
-/**
- * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject}
- * internally.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. To create a connectable observable that uses a
- * {@link ReplaySubject} under the hood, use {@link connectable}.
- * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to
- * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead.
- * `publishReplay(size, time, scheduler), refCount()` is equivalent to
- * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishReplay<T>(bufferSize?: number, windowTime?: number, timestampProvider?: TimestampProvider): MonoTypeOperatorFunction<T>;
-/**
- * Creates an observable, that when subscribed to, will create a {@link ReplaySubject},
- * and pass an observable from it (using [asObservable](api/index/class/Subject#asObservable)) to
- * the `selector` function, which then returns an observable that is subscribed to before
- * "connecting" the source to the internal `ReplaySubject`.
- *
- * Since this is deprecated, for additional details see the documentation for {@link connect}.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param selector A function used to setup the multicast.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `source.pipe(publishReplay(size, window, selector, scheduler))` is equivalent to
- * `source.pipe(connect(selector, { connector: () => new ReplaySubject(size, window, scheduler) }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishReplay<T, O extends ObservableInput<any>>(bufferSize: number | undefined, windowTime: number | undefined, selector: (shared: Observable<T>) => O, timestampProvider?: TimestampProvider): OperatorFunction<T, ObservedValueOf<O>>;
-/**
- * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject}
- * internally.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param selector Passing `undefined` here determines that this operator will return a {@link ConnectableObservable}.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. To create a connectable observable that uses a
- * {@link ReplaySubject} under the hood, use {@link connectable}.
- * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to
- * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead.
- * `publishReplay(size, time, scheduler), refCount()` is equivalent to
- * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishReplay<T, O extends ObservableInput<any>>(bufferSize: number | undefined, windowTime: number | undefined, selector: undefined, timestampProvider: TimestampProvider): OperatorFunction<T, ObservedValueOf<O>>;
-//# sourceMappingURL=publishReplay.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/race.d.ts

@@ -1,6 +0,0 @@
-import { ObservableInputTuple, OperatorFunction } from '../types';
-/** @deprecated Replaced with {@link raceWith}. Will be removed in v8. */
-export declare function race<T, A extends readonly unknown[]>(otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-/** @deprecated Replaced with {@link raceWith}. Will be removed in v8. */
-export declare function race<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-//# sourceMappingURL=race.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/raceWith.d.ts

@@ -1,29 +0,0 @@
-import { OperatorFunction, ObservableInputTuple } from '../types';
-/**
- * Creates an Observable that mirrors the first source Observable to emit a next,
- * error or complete notification from the combination of the Observable to which
- * the operator is applied and supplied Observables.
- *
- * ## Example
- *
- * ```ts
- * import { interval, map, raceWith } from 'rxjs';
- *
- * const obs1 = interval(7000).pipe(map(() => 'slow one'));
- * const obs2 = interval(3000).pipe(map(() => 'fast one'));
- * const obs3 = interval(5000).pipe(map(() => 'medium one'));
- *
- * obs1
- *   .pipe(raceWith(obs2, obs3))
- *   .subscribe(winner => console.log(winner));
- *
- * // Outputs
- * // a series of 'fast one'
- * ```
- *
- * @param otherSources Sources used to race for which Observable emits first.
- * @return A function that returns an Observable that mirrors the output of the
- * first Observable to emit an item.
- */
-export declare function raceWith<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-//# sourceMappingURL=raceWith.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/reduce.d.ts

@@ -1,5 +0,0 @@
-import { OperatorFunction } from '../types';
-export declare function reduce<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
-export declare function reduce<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
-export declare function reduce<V, A, S = A>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
-//# sourceMappingURL=reduce.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/refCount.d.ts

@@ -1,61 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * Make a {@link ConnectableObservable} behave like a ordinary observable and automates the way
- * you can connect to it.
- *
- * Internally it counts the subscriptions to the observable and subscribes (only once) to the source if
- * the number of subscriptions is larger than 0. If the number of subscriptions is smaller than 1, it
- * unsubscribes from the source. This way you can make sure that everything before the *published*
- * refCount has only a single subscription independently of the number of subscribers to the target
- * observable.
- *
- * Note that using the {@link share} operator is exactly the same as using the `multicast(() => new Subject())` operator
- * (making the observable hot) and the *refCount* operator in a sequence.
- *
- * ![](refCount.png)
- *
- * ## Example
- *
- * In the following example there are two intervals turned into connectable observables
- * by using the *publish* operator. The first one uses the *refCount* operator, the
- * second one does not use it. You will notice that a connectable observable does nothing
- * until you call its connect function.
- *
- * ```ts
- * import { interval, tap, publish, refCount } from 'rxjs';
- *
- * // Turn the interval observable into a ConnectableObservable (hot)
- * const refCountInterval = interval(400).pipe(
- *   tap(num => console.log(`refCount ${ num }`)),
- *   publish(),
- *   refCount()
- * );
- *
- * const publishedInterval = interval(400).pipe(
- *   tap(num => console.log(`publish ${ num }`)),
- *   publish()
- * );
- *
- * refCountInterval.subscribe();
- * refCountInterval.subscribe();
- * // 'refCount 0' -----> 'refCount 1' -----> etc
- * // All subscriptions will receive the same value and the tap (and
- * // every other operator) before the `publish` operator will be executed
- * // only once per event independently of the number of subscriptions.
- *
- * publishedInterval.subscribe();
- * // Nothing happens until you call .connect() on the observable.
- * ```
- *
- * @return A function that returns an Observable that automates the connection
- * to ConnectableObservable.
- * @see {@link ConnectableObservable}
- * @see {@link share}
- * @see {@link publish}
- * @deprecated Replaced with the {@link share} operator. How `share` is used
- * will depend on the connectable observable you created just prior to the
- * `refCount` operator.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function refCount<T>(): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=refCount.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/repeat.d.ts

@@ -1,108 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-export interface RepeatConfig {
-    /**
-     * The number of times to repeat the source. Defaults to `Infinity`.
-     */
-    count?: number;
-    /**
-     * If a `number`, will delay the repeat of the source by that number of milliseconds.
-     * If a function, it will provide the number of times the source has been subscribed to,
-     * and the return value should be a valid observable input that will notify when the source
-     * should be repeated. If the notifier observable is empty, the result will complete.
-     */
-    delay?: number | ((count: number) => ObservableInput<any>);
-}
-/**
- * Returns an Observable that will resubscribe to the source stream when the source stream completes.
- *
- * <span class="informal">Repeats all values emitted on the source. It's like {@link retry}, but for non error cases.</span>
- *
- * ![](repeat.png)
- *
- * Repeat will output values from a source until the source completes, then it will resubscribe to the
- * source a specified number of times, with a specified delay. Repeat can be particularly useful in
- * combination with closing operators like {@link take}, {@link takeUntil}, {@link first}, or {@link takeWhile},
- * as it can be used to restart a source again from scratch.
- *
- * Repeat is very similar to {@link retry}, where {@link retry} will resubscribe to the source in the error case, but
- * `repeat` will resubscribe if the source completes.
- *
- * Note that `repeat` will _not_ catch errors. Use {@link retry} for that.
- *
- * - `repeat(0)` returns an empty observable
- * - `repeat()` will repeat forever
- * - `repeat({ delay: 200 })` will repeat forever, with a delay of 200ms between repetitions.
- * - `repeat({ count: 2, delay: 400 })` will repeat twice, with a delay of 400ms between repetitions.
- * - `repeat({ delay: (count) => timer(count * 1000) })` will repeat forever, but will have a delay that grows by one second for each repetition.
- *
- * ## Example
- *
- * Repeat a message stream
- *
- * ```ts
- * import { of, repeat } from 'rxjs';
- *
- * const source = of('Repeat message');
- * const result = source.pipe(repeat(3));
- *
- * result.subscribe(x => console.log(x));
- *
- * // Results
- * // 'Repeat message'
- * // 'Repeat message'
- * // 'Repeat message'
- * ```
- *
- * Repeat 3 values, 2 times
- *
- * ```ts
- * import { interval, take, repeat } from 'rxjs';
- *
- * const source = interval(1000);
- * const result = source.pipe(take(3), repeat(2));
- *
- * result.subscribe(x => console.log(x));
- *
- * // Results every second
- * // 0
- * // 1
- * // 2
- * // 0
- * // 1
- * // 2
- * ```
- *
- * Defining two complex repeats with delays on the same source.
- * Note that the second repeat cannot be called until the first
- * repeat as exhausted it's count.
- *
- * ```ts
- * import { defer, of, repeat } from 'rxjs';
- *
- * const source = defer(() => {
- *    return of(`Hello, it is ${new Date()}`)
- * });
- *
- * source.pipe(
- *    // Repeat 3 times with a delay of 1 second between repetitions
- *    repeat({
- *      count: 3,
- *      delay: 1000,
- *    }),
- *
- *    // *Then* repeat forever, but with an exponential step-back
- *    // maxing out at 1 minute.
- *    repeat({
- *      delay: (count) => timer(Math.min(60000, 2 ^ count * 1000))
- *    })
- * )
- * ```
- *
- * @see {@link repeatWhen}
- * @see {@link retry}
- *
- * @param countOrConfig Either the number of times the source Observable items are repeated
- * (a count of 0 will yield an empty Observable) or a {@link RepeatConfig} object.
- */
-export declare function repeat<T>(countOrConfig?: number | RepeatConfig): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=repeat.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/repeatWhen.d.ts

@@ -1,38 +0,0 @@
-import { Observable } from '../Observable';
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-/**
- * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source
- * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable
- * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise
- * this method will resubscribe to the source Observable.
- *
- * ![](repeatWhen.png)
- *
- * ## Example
- *
- * Repeat a message stream on click
- *
- * ```ts
- * import { of, fromEvent, repeatWhen } from 'rxjs';
- *
- * const source = of('Repeat message');
- * const documentClick$ = fromEvent(document, 'click');
- *
- * const result = source.pipe(repeatWhen(() => documentClick$));
- *
- * result.subscribe(data => console.log(data))
- * ```
- *
- * @see {@link repeat}
- * @see {@link retry}
- * @see {@link retryWhen}
- *
- * @param notifier Function that receives an Observable of notifications with
- * which a user can `complete` or `error`, aborting the repetition.
- * @return A function that returns an Observable that mirrors the source
- * Observable with the exception of a `complete`.
- * @deprecated Will be removed in v9 or v10. Use {@link repeat}'s {@link RepeatConfig#delay delay} option instead.
- * Instead of `repeatWhen(() => notify$)`, use: `repeat({ delay: () => notify$ })`.
- */
-export declare function repeatWhen<T>(notifier: (notifications: Observable<void>) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=repeatWhen.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/retry.d.ts

@@ -1,28 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-/**
- * The {@link retry} operator configuration object. `retry` either accepts a `number`
- * or an object described by this interface.
- */
-export interface RetryConfig {
-    /**
-     * The maximum number of times to retry. If `count` is omitted, `retry` will try to
-     * resubscribe on errors infinite number of times.
-     */
-    count?: number;
-    /**
-     * The number of milliseconds to delay before retrying, OR a function to
-     * return a notifier for delaying. If a function is given, that function should
-     * return a notifier that, when it emits will retry the source. If the notifier
-     * completes _without_ emitting, the resulting observable will complete without error,
-     * if the notifier errors, the error will be pushed to the result.
-     */
-    delay?: number | ((error: any, retryCount: number) => ObservableInput<any>);
-    /**
-     * Whether or not to reset the retry counter when the retried subscription
-     * emits its first value.
-     */
-    resetOnSuccess?: boolean;
-}
-export declare function retry<T>(count?: number): MonoTypeOperatorFunction<T>;
-export declare function retry<T>(config: RetryConfig): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=retry.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/retryWhen.d.ts

@@ -1,61 +0,0 @@
-import { Observable } from '../Observable';
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-/**
- * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
- * calls `error`, this method will emit the Throwable that caused the error to the `ObservableInput` returned from `notifier`.
- * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
- * subscription. Otherwise this method will resubscribe to the source Observable.
- *
- * ![](retryWhen.png)
- *
- * Retry an observable sequence on error based on custom criteria.
- *
- * ## Example
- *
- * ```ts
- * import { interval, map, retryWhen, tap, delayWhen, timer } from 'rxjs';
- *
- * const source = interval(1000);
- * const result = source.pipe(
- *   map(value => {
- *     if (value > 5) {
- *       // error will be picked up by retryWhen
- *       throw value;
- *     }
- *     return value;
- *   }),
- *   retryWhen(errors =>
- *     errors.pipe(
- *       // log error message
- *       tap(value => console.log(`Value ${ value } was too high!`)),
- *       // restart in 5 seconds
- *       delayWhen(value => timer(value * 1000))
- *     )
- *   )
- * );
- *
- * result.subscribe(value => console.log(value));
- *
- * // results:
- * // 0
- * // 1
- * // 2
- * // 3
- * // 4
- * // 5
- * // 'Value 6 was too high!'
- * // - Wait 5 seconds then repeat
- * ```
- *
- * @see {@link retry}
- *
- * @param notifier Function that receives an Observable of notifications with which a
- * user can `complete` or `error`, aborting the retry.
- * @return A function that returns an Observable that mirrors the source
- * Observable with the exception of an `error`.
- * @deprecated Will be removed in v9 or v10, use {@link retry}'s `delay` option instead.
- * Will be removed in v9 or v10. Use {@link retry}'s {@link RetryConfig#delay delay} option instead.
- * Instead of `retryWhen(() => notify$)`, use: `retry({ delay: () => notify$ })`.
- */
-export declare function retryWhen<T>(notifier: (errors: Observable<any>) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=retryWhen.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/sample.d.ts

@@ -1,43 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-/**
- * Emits the most recently emitted value from the source Observable whenever
- * another Observable, the `notifier`, emits.
- *
- * <span class="informal">It's like {@link sampleTime}, but samples whenever
- * the `notifier` `ObservableInput` emits something.</span>
- *
- * ![](sample.png)
- *
- * Whenever the `notifier` `ObservableInput` emits a value, `sample`
- * looks at the source Observable and emits whichever value it has most recently
- * emitted since the previous sampling, unless the source has not emitted
- * anything since the previous sampling. The `notifier` is subscribed to as soon
- * as the output Observable is subscribed.
- *
- * ## Example
- *
- * On every click, sample the most recent `seconds` timer
- *
- * ```ts
- * import { fromEvent, interval, sample } from 'rxjs';
- *
- * const seconds = interval(1000);
- * const clicks = fromEvent(document, 'click');
- * const result = seconds.pipe(sample(clicks));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link audit}
- * @see {@link debounce}
- * @see {@link sampleTime}
- * @see {@link throttle}
- *
- * @param notifier The `ObservableInput` to use for sampling the
- * source Observable.
- * @return A function that returns an Observable that emits the results of
- * sampling the values emitted by the source Observable whenever the notifier
- * Observable emits value or completes.
- */
-export declare function sample<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=sample.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/sampleTime.d.ts

@@ -1,46 +0,0 @@
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
-/**
- * Emits the most recently emitted value from the source Observable within
- * periodic time intervals.
- *
- * <span class="informal">Samples the source Observable at periodic time
- * intervals, emitting what it samples.</span>
- *
- * ![](sampleTime.png)
- *
- * `sampleTime` periodically looks at the source Observable and emits whichever
- * value it has most recently emitted since the previous sampling, unless the
- * source has not emitted anything since the previous sampling. The sampling
- * happens periodically in time every `period` milliseconds (or the time unit
- * defined by the optional `scheduler` argument). The sampling starts as soon as
- * the output Observable is subscribed.
- *
- * ## Example
- *
- * Every second, emit the most recent click at most once
- *
- * ```ts
- * import { fromEvent, sampleTime } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(sampleTime(1000));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link auditTime}
- * @see {@link debounceTime}
- * @see {@link delay}
- * @see {@link sample}
- * @see {@link throttleTime}
- *
- * @param period The sampling period expressed in milliseconds or the time unit
- * determined internally by the optional `scheduler`.
- * @param scheduler The {@link SchedulerLike} to use for managing the timers
- * that handle the sampling.
- * @return A function that returns an Observable that emits the results of
- * sampling the values emitted by the source Observable at the specified time
- * interval.
- */
-export declare function sampleTime<T>(period: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=sampleTime.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/scan.d.ts

@@ -1,5 +0,0 @@
-import { OperatorFunction } from '../types';
-export declare function scan<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
-export declare function scan<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
-export declare function scan<V, A, S>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
-//# sourceMappingURL=scan.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/scanInternals.d.ts

@@ -1,12 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-/**
- * A basic scan operation. This is used for `scan` and `reduce`.
- * @param accumulator The accumulator to use
- * @param seed The seed value for the state to accumulate
- * @param hasSeed Whether or not a seed was provided
- * @param emitOnNext Whether or not to emit the state on next
- * @param emitBeforeComplete Whether or not to emit the before completion
- */
-export declare function scanInternals<V, A, S>(accumulator: (acc: V | A | S, value: V, index: number) => A, seed: S, hasSeed: boolean, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<V>, subscriber: Subscriber<any>) => void;
-//# sourceMappingURL=scanInternals.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/sequenceEqual.d.ts

@@ -1,60 +0,0 @@
-import { OperatorFunction, ObservableInput } from '../types';
-/**
- * Compares all values of two observables in sequence using an optional comparator function
- * and returns an observable of a single boolean value representing whether or not the two sequences
- * are equal.
- *
- * <span class="informal">Checks to see of all values emitted by both observables are equal, in order.</span>
- *
- * ![](sequenceEqual.png)
- *
- * `sequenceEqual` subscribes to source observable and `compareTo` `ObservableInput` (that internally
- * gets converted to an observable) and buffers incoming values from each observable. Whenever either
- * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom
- * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the
- * observables completes, the operator will wait for the other observable to complete; If the other
- * observable emits before completing, the returned observable will emit `false` and complete. If one observable never
- * completes or emits after the other completes, the returned observable will never complete.
- *
- * ## Example
- *
- * Figure out if the Konami code matches
- *
- * ```ts
- * import { from, fromEvent, map, bufferCount, mergeMap, sequenceEqual } from 'rxjs';
- *
- * const codes = from([
- *   'ArrowUp',
- *   'ArrowUp',
- *   'ArrowDown',
- *   'ArrowDown',
- *   'ArrowLeft',
- *   'ArrowRight',
- *   'ArrowLeft',
- *   'ArrowRight',
- *   'KeyB',
- *   'KeyA',
- *   'Enter', // no start key, clearly.
- * ]);
- *
- * const keys = fromEvent<KeyboardEvent>(document, 'keyup').pipe(map(e => e.code));
- * const matches = keys.pipe(
- *   bufferCount(11, 1),
- *   mergeMap(last11 => from(last11).pipe(sequenceEqual(codes)))
- * );
- * matches.subscribe(matched => console.log('Successful cheat at Contra? ', matched));
- * ```
- *
- * @see {@link combineLatest}
- * @see {@link zip}
- * @see {@link withLatestFrom}
- *
- * @param compareTo The `ObservableInput` sequence to compare the source sequence to.
- * @param comparator An optional function to compare each value pair.
- *
- * @return A function that returns an Observable that emits a single boolean
- * value representing whether or not the values emitted by the source
- * Observable and provided `ObservableInput` were equal in sequence.
- */
-export declare function sequenceEqual<T>(compareTo: ObservableInput<T>, comparator?: (a: T, b: T) => boolean): OperatorFunction<T, boolean>;
-//# sourceMappingURL=sequenceEqual.d.ts.map