@synstack/resolved/dist/callable/callable.index.d.ts

Type-safe piping of synchronous or asynchronous values

import { a as Resolvable } from '../resolvable.lib-CH4uXiBW.js';

type Callable<T> = T | (() => T);
declare namespace Callable {
    type Infer<T> = T extends () => infer U ? U : T;
    type IsPromise<T> = T extends () => infer U ? Resolvable.IsPromise<U> : Resolvable.IsPromise<T>;
}
type CallableResolvable<T> = Callable<Resolvable<T>>;
declare namespace CallableResolvable {
    type Infer<T> = Resolvable.Infer<Callable.Infer<T>>;
    type IsPromise<T> = Resolvable.IsPromise<Callable.Infer<T>>;
    type Return<T> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
    type MaybeArray<T> = CallableResolvable<T> | Array<CallableResolvable<T>>;
    namespace MaybeArray {
        type InferExact<T> = T extends readonly any[] ? {
            [K in keyof T]: CallableResolvable.Infer<T[K]>;
        } : CallableResolvable.Infer<T>;
        type Infer<T> = T extends readonly any[] ? Array<{
            [K in keyof T]: CallableResolvable.Infer<T[K]>;
        }[number]> : CallableResolvable.Infer<T>;
        type IsPromise<T> = T extends readonly any[] ? {
            [K in keyof T]: CallableResolvable.IsPromise<T[K]>;
        }[number] : CallableResolvable.IsPromise<T>;
        type Return<T> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
        type ArrayOf<T> = Array<MaybeArray<T>>;
        namespace ArrayOf {
            type InferExact<T extends readonly any[]> = {
                [K in keyof T]: MaybeArray.InferExact<T[K]>;
            };
            type Infer<T extends readonly any[]> = Array<{
                [K in keyof T]: MaybeArray.Infer<T[K]>;
            }[number]>;
            type IsPromise<T extends readonly any[]> = {
                [K in keyof T]: MaybeArray.IsPromise<T[K]>;
            }[number];
            type Return<T extends readonly any[]> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
        }
    }
}
declare const resolveNested: <T extends readonly any[]>(args: T) => CallableResolvable.MaybeArray.ArrayOf.Return<T>;

declare const callable_bundle_resolveNested: typeof resolveNested;
declare namespace callable_bundle {
  export { callable_bundle_resolveNested as resolveNested };
}

export { Callable, CallableResolvable, callable_bundle as callable, callable_bundle as default, resolveNested };