@augment-vir/common 20.0.1 → 21.0.1

package/dist/cjs/augments/error.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeAndReturnError = exports.wrapInTry = exports.ensureErrorAndPrependMessage = exports.ensureError = exports.extractErrorMessage = exports.combineErrorMessages = exports.combineErrors = void 0;
-const __1 = require("..");
+const boolean_1 = require("./boolean");
+const typed_has_property_1 = require("./object/typed-has-property");
+const promise_1 = require("./promise/promise");
 function combineErrors(errors) {
     if (!errors || errors.length === 0) {
         return undefined;
@@ -17,7 +19,7 @@ function combineErrorMessages(errors) {
     if (!errors) {
         return '';
     }
-    return errors.map(extractErrorMessage).filter(__1.isTruthy).join('\n');
+    return errors.map(extractErrorMessage).filter(boolean_1.isTruthy).join('\n');
 }
 exports.combineErrorMessages = combineErrorMessages;
 function extractErrorMessage(maybeError) {
@@ -27,7 +29,7 @@ function extractErrorMessage(maybeError) {
     if (maybeError instanceof Error) {
         return maybeError.message;
     }
-    else if ((0, __1.typedHasProperty)(maybeError, 'message')) {
+    else if ((0, typed_has_property_1.typedHasProperty)(maybeError, 'message')) {
         return String(maybeError.message);
     }
     else {
@@ -68,7 +70,7 @@ function executeAndReturnError(callback) {
     let caughtError;
     try {
         const result = callback();
-        if ((0, __1.isPromiseLike)(result)) {
+        if ((0, promise_1.isPromiseLike)(result)) {
             return new Promise(async (resolve) => {
                 try {
                     const output = await result;

package/dist/cjs/augments/promise/deferred-promise.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeferredPromiseWrapper = void 0;
+function createDeferredPromiseWrapper() {
+    let resolve;
+    let reject;
+    let settled = false;
+    const promise = new Promise((resolveCallback, rejectCallback) => {
+        resolve = (value) => {
+            settled = true;
+            return resolveCallback(value);
+        };
+        reject = (reason) => {
+            settled = true;
+            rejectCallback(reason);
+        };
+    });
+    // no way to test this edge case
+    // istanbul ignore next
+    if (!resolve || !reject) {
+        throw new Error(`Reject and resolve callbacks were not set by the promise constructor for ${createDeferredPromiseWrapper.name}.`);
+    }
+    return {
+        promise,
+        resolve,
+        reject,
+        isSettled() {
+            return settled;
+        },
+    };
+}
+exports.createDeferredPromiseWrapper = createDeferredPromiseWrapper;

package/dist/cjs/augments/promise/promise.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAsynchronously = exports.wrapPromiseInTimeout = exports.PromiseTimeoutError = exports.isPromiseLike = void 0;
+const typed_has_property_1 = require("../object/typed-has-property");
+function isPromiseLike(input) {
+    if ((0, typed_has_property_1.typedHasProperty)(input, 'then') && typeof input.then === 'function') {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+exports.isPromiseLike = isPromiseLike;
+class PromiseTimeoutError extends Error {
+    constructor(durationMs, message = `Promised timed out after ${durationMs} ms.`) {
+        super(message);
+        this.durationMs = durationMs;
+        this.message = message;
+        this.name = 'PromiseTimeoutError';
+    }
+}
+exports.PromiseTimeoutError = PromiseTimeoutError;
+function wrapPromiseInTimeout(durationMs, originalPromise) {
+    return new Promise(async (resolve, reject) => {
+        const timeoutId = durationMs === Infinity
+            ? undefined
+            : setTimeout(() => {
+                reject(new PromiseTimeoutError(durationMs));
+            }, durationMs);
+        try {
+            const result = await originalPromise;
+            resolve(result);
+        }
+        catch (error) {
+            reject(error);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    });
+}
+exports.wrapPromiseInTimeout = wrapPromiseInTimeout;
+/**
+ * Call a function asynchronously without interrupting current synchronous execution, even if the
+ * function was originally synchronous.
+ */
+async function callAsynchronously(callback) {
+    return await Promise.resolve().then(() => callback());
+}
+exports.callAsynchronously = callAsynchronously;

package/dist/cjs/augments/promise/wait.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForCondition = exports.waitValue = exports.wait = void 0;
+const error_1 = require("../error");
+const deferred_promise_1 = require("./deferred-promise");
+function wait(delayMs) {
+    const deferredPromiseWrapper = (0, deferred_promise_1.createDeferredPromiseWrapper)();
+    if (delayMs !== Infinity) {
+        setTimeout(() => {
+            deferredPromiseWrapper.resolve();
+        }, delayMs <= 0 ? 0 : delayMs);
+    }
+    return deferredPromiseWrapper.promise;
+}
+exports.wait = wait;
+async function waitValue(delayMs, returnValue) {
+    return wait(delayMs).then(() => returnValue);
+}
+exports.waitValue = waitValue;
+async function waitForCondition({ conditionCallback, timeoutMs = 10000, intervalMs = 100, timeoutMessage = '', }) {
+    let condition = false;
+    let lastError;
+    async function checkCondition() {
+        try {
+            condition = !!(await conditionCallback());
+        }
+        catch (error) {
+            condition = false;
+            lastError = error;
+        }
+    }
+    const startTime = Date.now();
+    await checkCondition();
+    while (!condition) {
+        await wait(intervalMs);
+        if (Date.now() - startTime >= timeoutMs) {
+            const message = timeoutMessage ? `${timeoutMessage}: ` : '';
+            throw new Error(`${message}Timeout of "${timeoutMs}" exceeded waiting for condition to be true${(0, error_1.extractErrorMessage)(lastError)}`);
+        }
+        await checkCondition();
+    }
+}
+exports.waitForCondition = waitForCondition;

package/dist/cjs/index.js

@@ -40,7 +40,9 @@ __exportStar(require("./augments/object/object-entries"), exports);
 __exportStar(require("./augments/object/old-union-to-intersection"), exports);
 __exportStar(require("./augments/object/pick-deep"), exports);
 __exportStar(require("./augments/object/typed-has-property"), exports);
-__exportStar(require("./augments/promise"), exports);
+__exportStar(require("./augments/promise/deferred-promise"), exports);
+__exportStar(require("./augments/promise/promise"), exports);
+__exportStar(require("./augments/promise/wait"), exports);
 __exportStar(require("./augments/random"), exports);
 __exportStar(require("./augments/regexp"), exports);
 __exportStar(require("./augments/runtime-type-of"), exports);

package/dist/esm/augments/error.js

@@ -1,4 +1,6 @@
-import { isPromiseLike, isTruthy, typedHasProperty } from '..';
+import { isTruthy } from './boolean';
+import { typedHasProperty } from './object/typed-has-property';
+import { isPromiseLike } from './promise/promise';
 export function combineErrors(errors) {
     if (!errors || errors.length === 0) {
         return undefined;

package/dist/esm/augments/promise/deferred-promise.js

@@ -0,0 +1,28 @@
+export function createDeferredPromiseWrapper() {
+    let resolve;
+    let reject;
+    let settled = false;
+    const promise = new Promise((resolveCallback, rejectCallback) => {
+        resolve = (value) => {
+            settled = true;
+            return resolveCallback(value);
+        };
+        reject = (reason) => {
+            settled = true;
+            rejectCallback(reason);
+        };
+    });
+    // no way to test this edge case
+    // istanbul ignore next
+    if (!resolve || !reject) {
+        throw new Error(`Reject and resolve callbacks were not set by the promise constructor for ${createDeferredPromiseWrapper.name}.`);
+    }
+    return {
+        promise,
+        resolve,
+        reject,
+        isSettled() {
+            return settled;
+        },
+    };
+}

package/dist/esm/augments/promise/promise.js

@@ -0,0 +1,43 @@
+import { typedHasProperty } from '../object/typed-has-property';
+export function isPromiseLike(input) {
+    if (typedHasProperty(input, 'then') && typeof input.then === 'function') {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export class PromiseTimeoutError extends Error {
+    constructor(durationMs, message = `Promised timed out after ${durationMs} ms.`) {
+        super(message);
+        this.durationMs = durationMs;
+        this.message = message;
+        this.name = 'PromiseTimeoutError';
+    }
+}
+export function wrapPromiseInTimeout(durationMs, originalPromise) {
+    return new Promise(async (resolve, reject) => {
+        const timeoutId = durationMs === Infinity
+            ? undefined
+            : setTimeout(() => {
+                reject(new PromiseTimeoutError(durationMs));
+            }, durationMs);
+        try {
+            const result = await originalPromise;
+            resolve(result);
+        }
+        catch (error) {
+            reject(error);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    });
+}
+/**
+ * Call a function asynchronously without interrupting current synchronous execution, even if the
+ * function was originally synchronous.
+ */
+export async function callAsynchronously(callback) {
+    return await Promise.resolve().then(() => callback());
+}

package/dist/esm/augments/promise/wait.js

@@ -0,0 +1,37 @@
+import { extractErrorMessage } from '../error';
+import { createDeferredPromiseWrapper } from './deferred-promise';
+export function wait(delayMs) {
+    const deferredPromiseWrapper = createDeferredPromiseWrapper();
+    if (delayMs !== Infinity) {
+        setTimeout(() => {
+            deferredPromiseWrapper.resolve();
+        }, delayMs <= 0 ? 0 : delayMs);
+    }
+    return deferredPromiseWrapper.promise;
+}
+export async function waitValue(delayMs, returnValue) {
+    return wait(delayMs).then(() => returnValue);
+}
+export async function waitForCondition({ conditionCallback, timeoutMs = 10000, intervalMs = 100, timeoutMessage = '', }) {
+    let condition = false;
+    let lastError;
+    async function checkCondition() {
+        try {
+            condition = !!(await conditionCallback());
+        }
+        catch (error) {
+            condition = false;
+            lastError = error;
+        }
+    }
+    const startTime = Date.now();
+    await checkCondition();
+    while (!condition) {
+        await wait(intervalMs);
+        if (Date.now() - startTime >= timeoutMs) {
+            const message = timeoutMessage ? `${timeoutMessage}: ` : '';
+            throw new Error(`${message}Timeout of "${timeoutMs}" exceeded waiting for condition to be true${extractErrorMessage(lastError)}`);
+        }
+        await checkCondition();
+    }
+}

package/dist/esm/index.js

@@ -24,7 +24,9 @@ export * from './augments/object/object-entries';
 export * from './augments/object/old-union-to-intersection';
 export * from './augments/object/pick-deep';
 export * from './augments/object/typed-has-property';
-export * from './augments/promise';
+export * from './augments/promise/deferred-promise';
+export * from './augments/promise/promise';
+export * from './augments/promise/wait';
 export * from './augments/random';
 export * from './augments/regexp';
 export * from './augments/runtime-type-of';

package/dist/types/augments/error.d.ts

@@ -1,5 +1,6 @@
 import { RequireExactlyOne } from 'type-fest';
-import { AtLeastTuple, NoInputsFunction } from '..';
+import { NoInputsFunction } from './function';
+import { AtLeastTuple } from './tuple';
 export declare function combineErrors(errors: AtLeastTuple<Error, 1>): Error;
 export declare function combineErrors(errors: ReadonlyArray<never>): undefined;
 export declare function combineErrors(errors: ReadonlyArray<Error>): Error | undefined;

package/dist/types/augments/object/pick-deep.d.ts

@@ -1,6 +1,13 @@
+import { AnyFunction } from '../function';
 import { NestedKeys } from './nested-keys';
 type InnerPickDeep<OriginalObjectGeneric extends object, DeepKeys extends any[]> = DeepKeys extends [infer CurrentLevelPick, ...infer RemainingKeys] ? {
-    [CurrentProp in Extract<CurrentLevelPick, keyof OriginalObjectGeneric>]: OriginalObjectGeneric[CurrentProp] extends object ? InnerPickDeep<OriginalObjectGeneric[CurrentProp], RemainingKeys> : OriginalObjectGeneric[CurrentProp];
+    [CurrentProp in Extract<CurrentLevelPick, keyof OriginalObjectGeneric>]: OriginalObjectGeneric[CurrentProp] extends AnyFunction ? OriginalObjectGeneric[CurrentProp] : OriginalObjectGeneric[CurrentProp] extends Array<any> ? OriginalObjectGeneric[CurrentProp] : OriginalObjectGeneric[CurrentProp] extends object ? InnerPickDeep<OriginalObjectGeneric[CurrentProp], RemainingKeys> : OriginalObjectGeneric[CurrentProp];
 } : DeepKeys extends [] ? OriginalObjectGeneric : DeepKeys extends [infer CurrentLevelPick] ? CurrentLevelPick extends keyof OriginalObjectGeneric ? Pick<OriginalObjectGeneric, CurrentLevelPick> : never : never;
-export type PickDeep<OriginalObjectGeneric extends object, DeepKeys extends NestedKeys<OriginalObjectGeneric>> = InnerPickDeep<OriginalObjectGeneric, DeepKeys>;
+/**
+ * Pick nested keys with more strict type parameter requirements. However, these stricter type
+ * parameter requirements often lead to "excessively deep" TS compiler errors.
+ */
+export type PickDeepStrict<OriginalObjectGeneric extends object, DeepKeys extends NestedKeys<OriginalObjectGeneric>> = InnerPickDeep<OriginalObjectGeneric, DeepKeys>;
+/** Pick nested keys. */
+export type PickDeep<OriginalObjectGeneric extends object, DeepKeys extends PropertyKey[]> = InnerPickDeep<OriginalObjectGeneric, DeepKeys>;
 export {};

package/dist/types/augments/promise/deferred-promise.d.ts

@@ -0,0 +1,8 @@
+/** A promise which can be resolved or rejected by external code. */
+export type DeferredPromiseWrapper<T> = {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    isSettled: () => boolean;
+};
+export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;

package/dist/types/augments/promise/promise.d.ts

@@ -0,0 +1,14 @@
+export declare function isPromiseLike<T>(input: T | unknown): input is T extends PromiseLike<infer ValueType> ? PromiseLike<ValueType> : PromiseLike<unknown>;
+export type MaybePromise<T> = Promise<T> | T;
+export declare class PromiseTimeoutError extends Error {
+    readonly durationMs: number;
+    readonly message: string;
+    readonly name = "PromiseTimeoutError";
+    constructor(durationMs: number, message?: string);
+}
+export declare function wrapPromiseInTimeout<PromiseValueType>(durationMs: number, originalPromise: PromiseLike<PromiseValueType>): Promise<PromiseValueType>;
+/**
+ * Call a function asynchronously without interrupting current synchronous execution, even if the
+ * function was originally synchronous.
+ */
+export declare function callAsynchronously<T>(callback: () => MaybePromise<T>): Promise<T>;

package/dist/types/augments/promise/wait.d.ts

@@ -0,0 +1,9 @@
+export declare function wait(delayMs: number): Promise<void>;
+export declare function waitValue<ResolutionValue>(delayMs: number, returnValue: ResolutionValue): Promise<ResolutionValue>;
+export type WaitForConditionInputs = {
+    conditionCallback: () => boolean | Promise<boolean>;
+    timeoutMs?: number;
+    intervalMs?: number;
+    timeoutMessage?: string;
+};
+export declare function waitForCondition({ conditionCallback, timeoutMs, intervalMs, timeoutMessage, }: WaitForConditionInputs): Promise<void>;

package/dist/types/index.d.ts

@@ -24,7 +24,9 @@ export * from './augments/object/object-entries';
 export * from './augments/object/old-union-to-intersection';
 export * from './augments/object/pick-deep';
 export * from './augments/object/typed-has-property';
-export * from './augments/promise';
+export * from './augments/promise/deferred-promise';
+export * from './augments/promise/promise';
+export * from './augments/promise/wait';
 export * from './augments/random';
 export * from './augments/regexp';
 export * from './augments/runtime-type-of';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/common",
-    "version": "20.0.1",
+    "version": "21.0.1",
     "homepage": "https://github.com/electrovir/augment-vir/tree/main/packages/common",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"

package/dist/cjs/augments/promise.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForCondition = exports.callAsynchronously = exports.createDeferredPromiseWrapper = exports.wrapPromiseInTimeout = exports.PromiseTimeoutError = exports.isPromiseLike = exports.waitValue = exports.wait = void 0;
-const error_1 = require("./error");
-const typed_has_property_1 = require("./object/typed-has-property");
-function wait(delayMs) {
-    const deferredPromiseWrapper = createDeferredPromiseWrapper();
-    if (delayMs !== Infinity) {
-        setTimeout(() => {
-            deferredPromiseWrapper.resolve();
-        }, delayMs <= 0 ? 0 : delayMs);
-    }
-    return deferredPromiseWrapper.promise;
-}
-exports.wait = wait;
-async function waitValue(delayMs, returnValue) {
-    return wait(delayMs).then(() => returnValue);
-}
-exports.waitValue = waitValue;
-function isPromiseLike(input) {
-    if ((0, typed_has_property_1.typedHasProperty)(input, 'then') && typeof input.then === 'function') {
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-exports.isPromiseLike = isPromiseLike;
-class PromiseTimeoutError extends Error {
-    constructor(durationMs, message = `Promised timed out after ${durationMs} ms.`) {
-        super(message);
-        this.durationMs = durationMs;
-        this.message = message;
-        this.name = 'PromiseTimeoutError';
-    }
-}
-exports.PromiseTimeoutError = PromiseTimeoutError;
-function wrapPromiseInTimeout(durationMs, originalPromise) {
-    return new Promise(async (resolve, reject) => {
-        const timeoutId = durationMs === Infinity
-            ? undefined
-            : setTimeout(() => {
-                reject(new PromiseTimeoutError(durationMs));
-            }, durationMs);
-        try {
-            const result = await originalPromise;
-            resolve(result);
-        }
-        catch (error) {
-            reject(error);
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    });
-}
-exports.wrapPromiseInTimeout = wrapPromiseInTimeout;
-function createDeferredPromiseWrapper() {
-    let resolve;
-    let reject;
-    let settled = false;
-    const promise = new Promise((resolveCallback, rejectCallback) => {
-        resolve = (value) => {
-            settled = true;
-            return resolveCallback(value);
-        };
-        reject = (reason) => {
-            settled = true;
-            rejectCallback(reason);
-        };
-    });
-    // no way to test this edge case
-    // istanbul ignore next
-    if (!resolve || !reject) {
-        throw new Error(`Reject and resolve callbacks were not set by the promise constructor for ${createDeferredPromiseWrapper.name}.`);
-    }
-    return {
-        promise,
-        resolve,
-        reject,
-        isSettled() {
-            return settled;
-        },
-    };
-}
-exports.createDeferredPromiseWrapper = createDeferredPromiseWrapper;
-/**
- * Call a function asynchronously without interrupting current synchronous execution, even if the
- * function was originally synchronous.
- */
-async function callAsynchronously(callback) {
-    return await Promise.resolve().then(() => callback());
-}
-exports.callAsynchronously = callAsynchronously;
-async function waitForCondition({ conditionCallback, timeoutMs = 10000, intervalMs = 100, timeoutMessage = '', }) {
-    let condition = false;
-    let lastError;
-    async function checkCondition() {
-        try {
-            condition = !!(await conditionCallback());
-        }
-        catch (error) {
-            condition = false;
-            lastError = error;
-        }
-    }
-    const startTime = Date.now();
-    await checkCondition();
-    while (!condition) {
-        await wait(intervalMs);
-        if (Date.now() - startTime >= timeoutMs) {
-            const message = timeoutMessage ? `${timeoutMessage}: ` : '';
-            throw new Error(`${message}Timeout of "${timeoutMs}" exceeded waiting for condition to be true${(0, error_1.extractErrorMessage)(lastError)}`);
-        }
-        await checkCondition();
-    }
-}
-exports.waitForCondition = waitForCondition;

package/dist/esm/augments/promise.js

@@ -1,107 +0,0 @@
-import { extractErrorMessage } from './error';
-import { typedHasProperty } from './object/typed-has-property';
-export function wait(delayMs) {
-    const deferredPromiseWrapper = createDeferredPromiseWrapper();
-    if (delayMs !== Infinity) {
-        setTimeout(() => {
-            deferredPromiseWrapper.resolve();
-        }, delayMs <= 0 ? 0 : delayMs);
-    }
-    return deferredPromiseWrapper.promise;
-}
-export async function waitValue(delayMs, returnValue) {
-    return wait(delayMs).then(() => returnValue);
-}
-export function isPromiseLike(input) {
-    if (typedHasProperty(input, 'then') && typeof input.then === 'function') {
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-export class PromiseTimeoutError extends Error {
-    constructor(durationMs, message = `Promised timed out after ${durationMs} ms.`) {
-        super(message);
-        this.durationMs = durationMs;
-        this.message = message;
-        this.name = 'PromiseTimeoutError';
-    }
-}
-export function wrapPromiseInTimeout(durationMs, originalPromise) {
-    return new Promise(async (resolve, reject) => {
-        const timeoutId = durationMs === Infinity
-            ? undefined
-            : setTimeout(() => {
-                reject(new PromiseTimeoutError(durationMs));
-            }, durationMs);
-        try {
-            const result = await originalPromise;
-            resolve(result);
-        }
-        catch (error) {
-            reject(error);
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    });
-}
-export function createDeferredPromiseWrapper() {
-    let resolve;
-    let reject;
-    let settled = false;
-    const promise = new Promise((resolveCallback, rejectCallback) => {
-        resolve = (value) => {
-            settled = true;
-            return resolveCallback(value);
-        };
-        reject = (reason) => {
-            settled = true;
-            rejectCallback(reason);
-        };
-    });
-    // no way to test this edge case
-    // istanbul ignore next
-    if (!resolve || !reject) {
-        throw new Error(`Reject and resolve callbacks were not set by the promise constructor for ${createDeferredPromiseWrapper.name}.`);
-    }
-    return {
-        promise,
-        resolve,
-        reject,
-        isSettled() {
-            return settled;
-        },
-    };
-}
-/**
- * Call a function asynchronously without interrupting current synchronous execution, even if the
- * function was originally synchronous.
- */
-export async function callAsynchronously(callback) {
-    return await Promise.resolve().then(() => callback());
-}
-export async function waitForCondition({ conditionCallback, timeoutMs = 10000, intervalMs = 100, timeoutMessage = '', }) {
-    let condition = false;
-    let lastError;
-    async function checkCondition() {
-        try {
-            condition = !!(await conditionCallback());
-        }
-        catch (error) {
-            condition = false;
-            lastError = error;
-        }
-    }
-    const startTime = Date.now();
-    await checkCondition();
-    while (!condition) {
-        await wait(intervalMs);
-        if (Date.now() - startTime >= timeoutMs) {
-            const message = timeoutMessage ? `${timeoutMessage}: ` : '';
-            throw new Error(`${message}Timeout of "${timeoutMs}" exceeded waiting for condition to be true${extractErrorMessage(lastError)}`);
-        }
-        await checkCondition();
-    }
-}

package/dist/types/augments/promise.d.ts

@@ -1,31 +0,0 @@
-export declare function wait(delayMs: number): Promise<void>;
-export declare function waitValue<ResolutionValue>(delayMs: number, returnValue: ResolutionValue): Promise<ResolutionValue>;
-export declare function isPromiseLike<T>(input: T | unknown): input is T extends PromiseLike<infer ValueType> ? PromiseLike<ValueType> : PromiseLike<unknown>;
-export type MaybePromise<T> = Promise<T> | T;
-export declare class PromiseTimeoutError extends Error {
-    readonly durationMs: number;
-    readonly message: string;
-    readonly name = "PromiseTimeoutError";
-    constructor(durationMs: number, message?: string);
-}
-export declare function wrapPromiseInTimeout<PromiseValueType>(durationMs: number, originalPromise: PromiseLike<PromiseValueType>): Promise<PromiseValueType>;
-/** A promise which can be resolved or rejected by external code. */
-export type DeferredPromiseWrapper<T> = {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-    isSettled: () => boolean;
-};
-export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;
-export type WaitForConditionInputs = {
-    conditionCallback: () => boolean | Promise<boolean>;
-    timeoutMs?: number;
-    intervalMs?: number;
-    timeoutMessage?: string;
-};
-/**
- * Call a function asynchronously without interrupting current synchronous execution, even if the
- * function was originally synchronous.
- */
-export declare function callAsynchronously<T>(callback: () => MaybePromise<T>): Promise<T>;
-export declare function waitForCondition({ conditionCallback, timeoutMs, intervalMs, timeoutMessage, }: WaitForConditionInputs): Promise<void>;