/** @packageDocumentation
 * @module Utils
 */
/** A duration of time. Can be either positive (towards future) or negative (in the past).
 * BeDurations are immutable.
 * @public
 */
export declare class BeDuration {
    private readonly _milliseconds;
    private constructor();
    /** The duration in milliseconds */
    get milliseconds(): number;
    get seconds(): number;
    /** Create a BeDuration from seconds.
     * @param seconds the number of seconds for this BeDuration
     */
    static fromSeconds(seconds: number): BeDuration;
    /** Create a BeDuration from milliseconds.
     * @param milliseconds the number of milliseconds for this BeDuration
     */
    static fromMilliseconds(milliseconds: number): BeDuration;
    /** Determine whether this BeDuration is 0 seconds */
    get isZero(): boolean;
    /** Determine whether this BeDuration is towards the future */
    get isTowardsFuture(): boolean;
    /** Determine whether this BeDuration is towards the past */
    get isTowardsPast(): boolean;
    /** Subtract a BeDuration from this BeDuration, returning a new BeDuration. */
    minus(other: BeDuration): BeDuration;
    /** Add a BeDuration to this BeDuration, returning a new BeDuration */
    plus(other: BeDuration): BeDuration;
    /** Utility function to just wait for the specified time
     * @param ms Duration in milliseconds to wait
     * @return Promise that resolves after the specified wait period
     */
    static wait(ms: number): Promise<void>;
    /** Utility function to wait for either the specified time or a promise, whichever resolves first
     * @param ms Maximum duration in milliseconds to wait
     * @param promise A pending promise to wait for
     * @return Promise that resolves after the specified wait period or the provided promise resolves, whichever comes first
     */
    static race<T>(ms: number, promise: PromiseLike<T>): Promise<T | void>;
    /** Utility function to just wait for the specified time
     * @return Promise that resolves after the specified wait period
     */
    wait(): Promise<void>;
    /** Execute a function after delaying by this duration.
     * @param fn the function to execute after the delay
     * @param scope An optional object scope to serve as the 'this' pointer when `fn` is invoked.
     * @param args optional arguments to `fn`
     * @return Promise resolved by `fn`
     */
    executeAfter<T>(fn: (...args: any[]) => T, scope?: any, ...args: any[]): Promise<T>;
}
/** A specific point in time relative to the current time.
 * BeTimePoints are used for timing operations. They are created from a BeDuration relative to the "now".
 * BeTimePoints are immutable.
 * @public
 */
export declare class BeTimePoint {
    private readonly _milliseconds;
    /** the time in milliseconds, of this BeTimePoint (relative to January 1, 1970 00:00:00 UTC.) */
    get milliseconds(): number;
    private constructor();
    /** Create a BeTimePoint from Date.now() */
    static now(): BeTimePoint;
    /** Create a BeTimePoint at a specified duration in the future from now
     *  @param val the duration from now
     */
    static fromNow(val: BeDuration): BeTimePoint;
    /** Create a BeTimePoint at a specified duration in the past before now
     * @param val the duration before now
     */
    static beforeNow(val: BeDuration): BeTimePoint;
    /** Determine whether this BeTimePoint is a time in the future from the time this method is called (it calls now()!) */
    get isInFuture(): boolean;
    /** Determine whether this BeTimePoint is a time that has already passed before the time this method is called (it calls now()!) */
    get isInPast(): boolean;
    /** Determine whether this BeTimePoint happens before another one.
     * @param other the other BeTimePoint.
     */
    before(other: BeTimePoint): boolean;
    /** Determine whether this BeTimePoint happens after another one.
     * @param other the other BeTimePoint.
     */
    after(other: BeTimePoint): boolean;
    /** Subtract a BeDuration from this BeTimePoint, returning a new BeTimePoint. This moves this BeTimePoint backwards in time if BeDuration.isTowardsFuture() === true
     * @param duration the duration to subtract.
     */
    minus(duration: BeDuration): BeTimePoint;
    /** Subtract a BeDuration from this BeTimePoint, returning a new BeTimePoint. This moves this BeTimePoint backwards in time if BeDuration.isTowardsFuture() === true
     * @param duration the duration to subtract.
     */
    plus(duration: BeDuration): BeTimePoint;
}
/** A StopWatch for timing operations.
 * @public
 */
export declare class StopWatch {
    description?: string | undefined;
    private _start?;
    private _stop?;
    /** Get the elapsed time since start() on a running timer. */
    get current(): BeDuration;
    /** Get the elapsed time, in seconds, since start() on a running timer. */
    get currentSeconds(): number;
    /** Get the elapsed time between start() and stop() on this timer in milliseconds. */
    get elapsed(): BeDuration;
    /** Get the elapsed time, in seconds, between start() and stop() on this  timer. */
    get elapsedSeconds(): number;
    /** ctor for StopWatch
     * @param description optional string stored with the StopWatch
     * @param startImmediately if true, StopWatch is started when created. Otherwise, call start() explicitly.
     */
    constructor(description?: string | undefined, startImmediately?: boolean);
    /** Start the stopwatch. Any future time measurements will be based on this new value. */
    start(): void;
    /** Stop the stopwatch so that the duration can be viewed later. */
    stop(): BeDuration;
    /** Clear the StopWatch */
    reset(): void;
}
//# sourceMappingURL=Time.d.ts.map