@augment-vir/assert 30.0.0

package/dist/augments/guards/wait-until.d.ts

@@ -0,0 +1,262 @@
+import { WaitUntilOptions } from '../../guard-types/wait-until-function.js';
+/**
+ * A group of guard methods that run the given callback multiple times until its return value
+ * matches expectations. Callback interval and timeout can be customized with
+ * {@link WaitUntilOptions}.
+ *
+ * @category Assert
+ * @example
+ *
+ * ```ts
+ * import {waitUntil} from '@augment-vir/assert';
+ *
+ * // `result` will eventually be `'123'`
+ * const result = await waitUntil.isString(
+ *     () => {
+ *         if (Math.random() < 0.5) {
+ *             return 123;
+ *         } else {
+ *             return '123';
+ *         }
+ *     },
+ *     {
+ *         interval: {milliseconds: 100},
+ *         timeout: {seconds: 10},
+ *     },
+ * );
+ * ```
+ *
+ * @returns The successful callback return value.
+ * @throws {@link AssertionError} When the assertion fails.
+ * @package @augment-vir/assert
+ */
+export declare const waitUntil: {
+    isTruthy: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("../assertion-exports.js").Truthy<Actual>>;
+    isFalsy: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("../assertion-exports.js").Falsy<Actual>>;
+    isTrue: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, true>>;
+    isFalse: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, false>>;
+    strictEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
+    deepEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
+    notStrictEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    looseEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    notLooseEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    notDeepEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    output: typeof import("../../assertions/output.js").waitUntilOutput;
+    isFunction: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>>;
+    isNotArray: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, ReadonlyArray<unknown>>>;
+    isNotBigInt: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, bigint>>;
+    isNotBoolean: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, boolean>>;
+    isNotFunction: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("@augment-vir/core").AnyFunction>>;
+    isNotNull: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, null>>;
+    isNotNumber: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, number>>;
+    isNotObject: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("@augment-vir/core").UnknownObject>>;
+    isNotString: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, string>>;
+    isNotUndefined: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined>>;
+    isNotSymbol: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, symbol>>;
+    isSymbol: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, symbol>>;
+    isUndefined: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, undefined>>;
+    isArray: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown[]>>;
+    isBigInt: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, bigint>>;
+    isBoolean: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, boolean>>;
+    isNull: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, null>>;
+    isNumber: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, number>>;
+    isObject: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, import("@augment-vir/core").UnknownObject>>;
+    isString: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, string>>;
+    throws: {
+        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, any> | Promise<any>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
+        (matchOptions: import("../assertion-exports.js").ErrorMatchOptions, callbackOrPromise: import("@augment-vir/core").TypedFunction<void, any> | Promise<any>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
+    };
+    isError: <Input extends unknown>(matchOptions: import("@augment-vir/core").PartialWithNullable<{
+        matchMessage: string | RegExp;
+        matchConstructor: ErrorConstructor | (new (...args: any[]) => Error);
+    }> | undefined, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, Error>>;
+    endsWith: {
+        <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
+        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
+        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
+    };
+    startsWith: {
+        <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
+        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
+        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
+    };
+    isEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(checkEnum: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected[keyof Expected]>>;
+    isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(checkEnum: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>>;
+    entriesEqual: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
+    notEntriesEqual: <Input extends object>(expected: object, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    jsonEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
+    notJsonEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(category: Category, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>>;
+    isHttpStatus: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, import("@augment-vir/core").HttpStatus>>;
+    instanceOf: <const Instance>(constructor: import("type-fest").Constructor<Instance>, callback: () => import("@augment-vir/core").MaybePromise<unknown>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Instance>;
+    notInstanceOf: <const Actual, const Instance>(constructor: import("type-fest").Constructor<Instance>, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Instance>>;
+    isKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Key, keyof Parent>>;
+    isNotKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>>;
+    hasKey: <const Parent, const Key extends PropertyKey>(key: Key, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>>;
+    lacksKey: <const Parent, const Key extends PropertyKey>(key: Key, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Record<Key, any>>>;
+    hasKeys: <const Keys extends PropertyKey, const Parent>(keys: ReadonlyArray<Keys>, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Parent & Record<Keys, (Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>>;
+    lacksKeys: <const Parent, const Keys extends PropertyKey>(keys: ReadonlyArray<Keys>, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Partial<Record<Keys, any>>>>;
+    isLengthAtLeast: {
+        <Element, Length extends number>(length: Length, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<Element | undefined>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<import("@augment-vir/core").AtLeastTuple<Element, Length>>;
+        <Actual extends string | import("@augment-vir/core").AnyObject>(length: number, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Actual>;
+    };
+    isLengthExactly: {
+        <Element, Length extends number>(length: Length, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<Element | undefined>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<import("@augment-vir/core").Tuple<Element, Length>>;
+        <Actual extends string | import("@augment-vir/core").AnyObject>(length: number, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Actual>;
+    };
+    isDefined: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined | null>>;
+    isNullish: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, null | undefined>>;
+    isAbove: <Input extends number>(expected: number, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isAtLeast: <Input extends number>(expected: number, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isBelow: <Input extends number>(expected: number, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isAtMost: <Input extends number>(expected: number, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isNaN: <Input extends number>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isFinite: <Input extends number>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isInfinite: <Input extends number>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isApproximately: <Input extends number>(expected: number, delta: number, params_2: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isNotApproximately: <Input extends number>(expected: number, delta: number, params_2: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isNotPrimitive: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("type-fest").Primitive>>;
+    isNotPropertyKey: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PropertyKey>>;
+    isPropertyKey: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, PropertyKey>>;
+    isPrimitive: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, import("type-fest").Primitive>>;
+    isNotPromise: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Promise<any>>>;
+    isNotPromiseLike: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PromiseLike<any>>>;
+    isPromise: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, Promise<any>>>;
+    isPromiseLike: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, PromiseLike<any>>>;
+    isNotUuid: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("@augment-vir/core").Uuid>>;
+    isUuid: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, `${string}-${string}-${string}-${string}-${string}`>>;
+    hasValue: <Input extends object>(value: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    lacksValue: <Input extends object>(value: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    hasValues: <Input extends object>(values: readonly unknown[], params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    lacksValues: <Input extends object>(values: readonly unknown[], params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    isIn: <const Child, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Child>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Child, import("@augment-vir/core").Values<Parent>>>;
+    isNotIn: <const Child, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Child>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Child, import("@augment-vir/core").Values<Parent>>>;
+    isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>>;
+    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("../assertion-exports.js").Empty>>;
+    matches: <Input extends string>(expected: RegExp, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    mismatches: <Input extends string>(expected: RegExp, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
+        interval: import("@date-vir/duration").AnyDuration;
+        timeout: import("@date-vir/duration").AnyDuration;
+    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
+    endsWithout: {
+        <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
+        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
+        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
+    };
+    startsWithout: {
+        <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
+        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
+        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
+    };
+};

package/dist/augments/guards/wait-until.example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/augments/guards/wait-until.example.js

@@ -0,0 +1,13 @@
+import { waitUntil } from '@augment-vir/assert';
+// `result` will eventually be `'123'`
+const result = await waitUntil.isString(() => {
+    if (Math.random() < 0.5) {
+        return 123;
+    }
+    else {
+        return '123';
+    }
+}, {
+    interval: { milliseconds: 100 },
+    timeout: { seconds: 10 },
+});

package/dist/augments/guards/wait-until.js

@@ -0,0 +1,34 @@
+import { extendableAssertions, waitUntilOverrides } from '../../assertions/extendable-assertions.js';
+import { createWaitUntilGroup } from '../../guard-types/wait-until-function.js';
+/**
+ * A group of guard methods that run the given callback multiple times until its return value
+ * matches expectations. Callback interval and timeout can be customized with
+ * {@link WaitUntilOptions}.
+ *
+ * @category Assert
+ * @example
+ *
+ * ```ts
+ * import {waitUntil} from '@augment-vir/assert';
+ *
+ * // `result` will eventually be `'123'`
+ * const result = await waitUntil.isString(
+ *     () => {
+ *         if (Math.random() < 0.5) {
+ *             return 123;
+ *         } else {
+ *             return '123';
+ *         }
+ *     },
+ *     {
+ *         interval: {milliseconds: 100},
+ *         timeout: {seconds: 10},
+ *     },
+ * );
+ * ```
+ *
+ * @returns The successful callback return value.
+ * @throws {@link AssertionError} When the assertion fails.
+ * @package @augment-vir/assert
+ */
+export const waitUntil = createWaitUntilGroup(extendableAssertions, waitUntilOverrides);

package/dist/augments/if-equals.d.ts

@@ -0,0 +1,17 @@
+import type { IsEqual } from 'type-fest';
+/**
+ * A helper type that resolves to the given `Yes` type parameter if `Actual` === `Expected`.
+ * Otherwise it resolves to the given `No` type parameter.
+ *
+ * @category Assert : Util
+ * @package @augment-vir/assert
+ */
+export type IfEquals<Actual, Expected, Yes = unknown, No = never> = IsEqual<Actual, Expected> extends true ? Yes : No;
+/**
+ * A helper type that resolves to the given `Yes` type parameter if `Actual` extends `Expected`.
+ * Otherwise it resolves to the given `No` type parameter.
+ *
+ * @category Assert : Util
+ * @package @augment-vir/assert
+ */
+export type IfExtends<Actual, Expected, Yes = unknown, No = never> = Actual extends Expected ? Yes : No;

package/dist/augments/if-equals.js

@@ -0,0 +1 @@
+export {};

package/dist/guard-types/assert-function.d.ts

@@ -0,0 +1,2 @@
+/** C8 fails in type-only files. */
+export type AssertFunction<Output> = (input: any, ...extraInputs: any[]) => asserts input is Output;

package/dist/guard-types/assert-function.js

@@ -0,0 +1,3 @@
+/* node:coverage disable */
+/** C8 fails in type-only files. */
+export {};

package/dist/guard-types/assert-wrap-function.d.ts

@@ -0,0 +1,9 @@
+import { AnyFunction, ExtractKeysWithMatchingValues, NarrowToExpected, Overwrite } from '@augment-vir/core';
+import { AssertFunction } from './assert-function.js';
+export type AssertWrapFunction<Output> = <Input>(input: Input, ...extraInputs: any[]) => NarrowToExpected<Input, Output>;
+export type AssertWrapOverridesBase = Readonly<Record<string, AnyFunction | undefined>>;
+export type AssertWrapGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, AssertWrapOverrides extends AssertWrapOverridesBase> = Omit<Overwrite<{
+    [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? AssertWrapFunction<Output> : never;
+}, AssertWrapOverrides>, ExtractKeysWithMatchingValues<AssertWrapOverrides, undefined>>;
+export declare function createAssertWrapGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const AssertWrapOverrides extends AssertWrapOverridesBase>(asserts: Asserts, assertWrapOverrides: AssertWrapOverrides): AssertWrapGroup<Asserts, AssertWrapOverrides>;
+export declare function createAssertWrap<const Output>(assert: AssertFunction<Output>): AssertWrapFunction<Output>;

package/dist/guard-types/assert-wrap-function.js

@@ -0,0 +1,14 @@
+import { pickOverride } from './guard-override.js';
+export function createAssertWrapGroup(asserts, assertWrapOverrides) {
+    const checks = Object.entries(asserts).reduce((accum, [name, assert,]) => {
+        accum[name] = pickOverride(assertWrapOverrides, name, () => createAssertWrap(assert));
+        return accum;
+    }, {});
+    return checks;
+}
+export function createAssertWrap(assert) {
+    return ((...inputs) => {
+        assert(...inputs);
+        return inputs[0];
+    });
+}

package/dist/guard-types/check-function.d.ts

@@ -0,0 +1,11 @@
+import { ExtractKeysWithMatchingValues, MaybePromise, Overwrite, RemoveFirstTupleEntry, RemoveLastTupleEntry } from '@augment-vir/core';
+import { AssertFunction } from './assert-function.js';
+export type CheckFunction<Output> = (input: any, ...extraInputs: any[]) => input is Output;
+export type GenericCheckFunction = (input: any, ...extraInputs: any[]) => MaybePromise<boolean> | never;
+export type CheckOverridesBase = Readonly<Record<string, CheckFunction<any> | GenericCheckFunction | undefined>>;
+export type CheckGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, CheckOverrides extends CheckOverridesBase> = Omit<Overwrite<{
+    [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? (input: Parameters<Asserts[Name]>[0], ...params: RemoveLastTupleEntry<RemoveFirstTupleEntry<Parameters<Asserts[Name]>>>) => input is Output : never;
+}, CheckOverrides>, ExtractKeysWithMatchingValues<CheckOverrides, undefined>>;
+export declare function createCheckGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const CheckOverrides extends CheckOverridesBase>(asserts: Asserts, checkOverrides: CheckOverrides): CheckGroup<Asserts, CheckOverrides>;
+export declare function createCheck<const Output>(assert: AssertFunction<Output>): CheckFunction<Output>;
+export declare function runAssertCheck<const Output, const Assert extends AssertFunction<Output>>(assert: Assert, input: Parameters<Assert>[0], ...inputs: RemoveFirstTupleEntry<RemoveLastTupleEntry<Parameters<Assert>>>): input is Output;

package/dist/guard-types/check-function.js

@@ -0,0 +1,22 @@
+import { pickOverride } from './guard-override.js';
+export function createCheckGroup(asserts, checkOverrides) {
+    const checks = Object.entries(asserts).reduce((accum, [name, assert,]) => {
+        accum[name] = pickOverride(checkOverrides, name, () => createCheck(assert));
+        return accum;
+    }, {});
+    return checks;
+}
+export function createCheck(assert) {
+    return ((...inputs) => {
+        return runAssertCheck(assert, ...inputs);
+    });
+}
+export function runAssertCheck(assert, input, ...inputs) {
+    try {
+        assert(input, ...inputs);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/guard-types/check-wrap-wrapper-function.d.ts

@@ -0,0 +1,9 @@
+import { ExtractKeysWithMatchingValues, Overwrite, type NarrowToActual } from '@augment-vir/core';
+import { AssertFunction } from './assert-function.js';
+import { AssertWrapOverridesBase } from './assert-wrap-function.js';
+export type CheckWrapFunction<Output> = <Input>(input: Input, ...extraInputs: any[]) => NarrowToActual<Input, Output> | undefined;
+export type CheckWrapGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, CheckWrapOverrides extends AssertWrapOverridesBase> = Omit<Overwrite<{
+    [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? CheckWrapFunction<Output> : never;
+}, CheckWrapOverrides>, ExtractKeysWithMatchingValues<CheckWrapOverrides, undefined>>;
+export declare function createCheckWrapGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const CheckWrapOverrides extends AssertWrapOverridesBase>(asserts: Asserts, checkWrapOverrides: CheckWrapOverrides): CheckWrapGroup<Asserts, CheckWrapOverrides>;
+export declare function createCheckWrap<const Output>(assert: AssertFunction<Output>): CheckWrapFunction<Output>;

package/dist/guard-types/check-wrap-wrapper-function.js

@@ -0,0 +1,19 @@
+import { pickOverride } from './guard-override.js';
+export function createCheckWrapGroup(asserts, checkWrapOverrides) {
+    const checks = Object.entries(asserts).reduce((accum, [name, assert,]) => {
+        accum[name] = pickOverride(checkWrapOverrides, name, () => createCheckWrap(assert));
+        return accum;
+    }, {});
+    return checks;
+}
+export function createCheckWrap(assert) {
+    return ((...inputs) => {
+        try {
+            assert(...inputs);
+            return inputs[0];
+        }
+        catch {
+            return undefined;
+        }
+    });
+}

package/dist/guard-types/guard-group.d.ts

@@ -0,0 +1,13 @@
+/** C8 fails in type-only files. */
+import type { AssertFunction } from './assert-function.js';
+import type { AssertWrapOverridesBase } from './assert-wrap-function.js';
+import type { CheckOverridesBase } from './check-function.js';
+import type { WaitUntilOverridesBase } from './wait-until-function.js';
+export type GuardGroup = {
+    assertions: Record<string, AssertFunction<any>>;
+} & Partial<{
+    checkOverrides: CheckOverridesBase;
+    assertWrapOverrides: AssertWrapOverridesBase;
+    checkWrapOverrides: AssertWrapOverridesBase;
+    waitUntilOverrides: WaitUntilOverridesBase;
+}>;

package/dist/guard-types/guard-group.js

@@ -0,0 +1,3 @@
+/* node:coverage disable */
+/** C8 fails in type-only files. */
+export {};

package/dist/guard-types/guard-override.d.ts

@@ -0,0 +1,4 @@
+import { AnyObject, Values } from '@augment-vir/core';
+export declare const autoGuardSymbol: unique symbol;
+export declare function autoGuard<T>(): T;
+export declare function pickOverride<Overrides extends AnyObject, Created>(overrides: Overrides, name: string, create: () => Created): Values<Overrides> | Created;

package/dist/guard-types/guard-override.js

@@ -0,0 +1,10 @@
+export const autoGuardSymbol = Symbol('auto guard');
+export function autoGuard() {
+    return autoGuardSymbol;
+}
+export function pickOverride(overrides, name, create) {
+    if (name in overrides && overrides[name] !== autoGuardSymbol) {
+        return overrides[name];
+    }
+    return create();
+}

package/dist/guard-types/wait-until-function.d.ts

@@ -0,0 +1,63 @@
+import type { AnyFunction, MaybePromise, NarrowToExpected, PartialWithUndefined, RemoveFirstTupleEntry, RemoveLastTupleEntry, RequiredAndNotNull } from '@augment-vir/core';
+import { ExtractKeysWithMatchingValues, Overwrite } from '@augment-vir/core';
+import { AnyDuration } from '@date-vir/duration';
+import type { AssertFunction } from './assert-function.js';
+/**
+ * Options for configuring the timing of `waitUntil`.
+ *
+ * @category Assert : Util
+ * @package @augment-vir/assert
+ */
+export type WaitUntilOptions = PartialWithUndefined<{
+    /**
+     * The duration between attempts.
+     *
+     * @default {milliseconds: 100}
+     */
+    interval: AnyDuration;
+    /**
+     * The maximum duration to keep trying. If the `waitUntil` expectations are still not met by
+     * this time, an {@link AssertionError} will be thrown.
+     *
+     * @default {seconds: 10}
+     */
+    timeout: AnyDuration;
+}>;
+export declare const defaultWaitUntilOptions: RequiredAndNotNull<WaitUntilOptions>;
+export type WaitUntilOverridesBase = Readonly<Record<string, AnyFunction>>;
+export type WaitUntilFunctionParameters<Assert extends AssertFunction<any>, Input> = [
+    ...RemoveFirstTupleEntry<RemoveLastTupleEntry<Parameters<Assert>>>,
+    () => MaybePromise<Input>
+];
+export type WaitUntilFunction<Assert extends AssertFunction<any>> = Assert extends AssertFunction<infer Guard> ? <Input extends Parameters<Assert>[0]>(...params: [
+    ...WaitUntilFunctionParameters<Assert, Input>,
+    options?: WaitUntilOptions | undefined,
+    failureMessage?: string | undefined
+]) => Promise<NarrowToExpected<Input, Guard>> : never;
+type WaitUntilGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, WaitUntilOverrides extends WaitUntilOverridesBase> = Omit<Overwrite<{
+    [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: WaitUntilFunction<Asserts[Name]>;
+}, WaitUntilOverrides>, ExtractKeysWithMatchingValues<WaitUntilOverrides, undefined>>;
+export declare function createWaitUntilGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const WaitUntilOverrides extends WaitUntilOverridesBase>(asserts: Asserts, waitUntilOverrides: WaitUntilOverrides): WaitUntilGroup<Asserts, WaitUntilOverrides>;
+export declare function createWaitUntil<const Assert extends AssertFunction<any>>(assert: Assert, requireSynchronousResult?: boolean): WaitUntilFunction<Assert>;
+export declare function parseWaitUntilArgs(rawArgs: unknown[]): {
+    callback: AnyFunction;
+    options: RequiredAndNotNull<PartialWithUndefined<{
+        /**
+         * The duration between attempts.
+         *
+         * @default {milliseconds: 100}
+         */
+        interval: AnyDuration;
+        /**
+         * The maximum duration to keep trying. If the `waitUntil` expectations are still not met by
+         * this time, an {@link AssertionError} will be thrown.
+         *
+         * @default {seconds: 10}
+         */
+        timeout: AnyDuration;
+    }>>;
+    extraAssertionArgs: unknown[];
+    failureMessage: string | undefined;
+};
+export declare function parseWaitUntilOptions(rawOptions: WaitUntilOptions | undefined): RequiredAndNotNull<WaitUntilOptions>;
+export {};