import { TypedValue } from '@xylabs/typeof';
export { isPromise } from '@xylabs/typeof';

/**
 * For use with Promise.allSettled to filter only successful results
 * @param val
 * @returns
 */
declare const fulfilled: <T>(val: PromiseSettledResult<T>) => val is PromiseFulfilledResult<T>;

/**
 * For use with Promise.allSettled to reduce to only successful result values
 * @example <caption>Casting the initialValue provided to reduce</caption>
 * const resolved = Promise.resolve('resolved')
 * const rejected = Promise.reject('rejected')
 * const settled = await Promise.allSettled([resolved, rejected])
 * const results = settled.reduce(fulfilledValues, [] as string[])
 * // results === [ 'resolved' ]
 * @example <caption>Providing type parameter to reduce and initialValue type can be inferred</caption>
 * const resolved = Promise.resolve('resolved')
 * const rejected = Promise.reject('rejected')
 * const settled = await Promise.allSettled([resolved, rejected])
 * const results = settled.reduce<string[]>(fulfilledValues, [])
 * // results === [ 'resolved' ]
 * @param previousValue
 * @param currentValue
 * @returns
 */
declare const fulfilledValues: <T>(previousValue: T[], currentValue: PromiseSettledResult<T>) => T[];

/** A resolve/reject callback used within PromiseEx. */
type PromiseExSubFunc<T, TResult = T> = (value: T) => TResult;
/** The executor function passed to the PromiseEx constructor. */
type PromiseExFunc<T> = (resolve?: PromiseExSubFunc<T, void>, reject?: PromiseExSubFunc<T, void>) => void;
/** A callback that inspects the attached value and returns whether to cancel the promise. */
type PromiseExValueFunc<V> = (value?: V) => boolean;
/**
 * An extended Promise that carries an optional attached value and supports cancellation.
 * The value can be inspected via the `then` or `value` methods to conditionally cancel.
 */
declare class PromiseEx<T, V = void> extends Promise<T> {
    /** Whether the promise has been cancelled via a value callback. */
    cancelled?: boolean;
    private _value?;
    constructor(func: PromiseExFunc<T>, value?: V);
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined, onvalue?: (value?: V) => boolean): Promise<TResult1 | TResult2>;
    /**
     * Inspects the attached value via the callback; if it returns true, marks the promise as cancelled.
     * @param onvalue - A callback that receives the attached value and returns whether to cancel.
     * @returns This instance for chaining.
     */
    value(onvalue?: (value?: V) => boolean): this;
}

/**
 * For use with Promise.allSettled to filter only rejected results
 * @param val
 * @returns
 */
declare const rejected: <T>(val: PromiseSettledResult<T>) => val is PromiseRejectedResult;

/** A value that may be a Promise, PromiseEx, or a plain synchronous value. */
type Promisable<T, V = never> = PromiseEx<T, V> | Promise<T> | T;
/** A Promisable that resolves to an array. */
type PromisableArray<T, V = never> = Promisable<T[], V>;
/** A Promisable that may resolve to undefined. */
type OptionalPromisable<T, V = never> = Promisable<T | undefined, V>;
/** A Promisable array where elements may be undefined. */
type OptionalPromisableArray<T, V = never> = PromisableArray<T | undefined, V>;
/** A Promisable that may resolve to null. */
type NullablePromisable<T, V = never> = Promisable<T | null, V>;
/** A Promisable array where elements may be null. */
type NullablePromisableArray<T, V = never> = PromisableArray<T | null, V>;
/** @description Used to document promises that are being used as Mutexes */
type AsyncMutex<T> = Promise<T>;
/** An interface representing any thenable (promise-like) object. */
interface PromiseType {
    then: () => unknown;
}
/** Any non-promise typed value, excluding thenables. */
type AnyNonPromise = Exclude<TypedValue, PromiseType>;

/**
 * Wraps a value in a Promise if it is not already one.
 * @param value - A value that may or may not be a Promise.
 * @returns A Promise resolving to the value.
 */
declare function toPromise<T>(value: Promisable<T>): Promise<T>;

export { PromiseEx, fulfilled, fulfilledValues, rejected, toPromise };
export type { AnyNonPromise, AsyncMutex, NullablePromisable, NullablePromisableArray, OptionalPromisable, OptionalPromisableArray, Promisable, PromisableArray, PromiseExFunc, PromiseExSubFunc, PromiseExValueFunc, PromiseType };