import * as vue from 'vue';
import { MaybeRefOrGetter, Ref } from 'vue';

type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
/**
 * will return `true` if `T` is `any`, or `false` otherwise
 */
type IsAny<T> = IfAny<T, true, false>;

/**
 * The source code for this function was inspired by vue-apollo's `useEventHook` util
 * https://github.com/vuejs/vue-apollo/blob/v4/packages/vue-apollo-composable/src/util/useEventHook.ts
 */

type Callback<T> = IsAny<T> extends true ? (...param: any) => void : ([
    T
] extends [void] ? (...param: unknown[]) => void : (...param: [T, ...unknown[]]) => void);
type EventHookOn<T = any> = (fn: Callback<T>) => {
    off: () => void;
};
type EventHookOff<T = any> = (fn: Callback<T>) => void;
type EventHookTrigger<T = any> = (...param: IsAny<T> extends true ? unknown[] : [T, ...unknown[]]) => Promise<unknown[]>;
interface EventHook<T = any> {
    on: EventHookOn<T>;
    off: EventHookOff<T>;
    trigger: EventHookTrigger<T>;
    clear: () => void;
}

type OptionsApiRequest<T> = (...args: any[]) => Promise<T[] | {
    data: T[] | {
        data: T[];
    };
}>;
interface OptionsApiConfig<T> {
    /** 请求选项数据源的方法 */
    api?: OptionsApiRequest<T>;
    /**
     * 请求参数
     *  - 会传入 `api` 方法
     *  - 支持传入一个函数, 返回一个对象
     *  - 当请求参数发生变化时, 会重新发起请求
     */
    params?: MaybeRefOrGetter<Record<string, any> | undefined>;
    /**
     * 是否立即发起请求
     * @default true
     */
    immediate?: boolean;
}
type OptionsApi<T> = OptionsApiRequest<T> | OptionsApiConfig<T>;
interface UseOptionsApiOptions {
    /** 请求参数 */
    params?: MaybeRefOrGetter<Record<string, any> | undefined>;
}
declare function useOptionsApi<T>(optionsApi: Ref<OptionsApi<T> | undefined>, options?: UseOptionsApiOptions): {
    propApi: vue.ComputedRef<OptionsApiRequest<T> | undefined>;
    api: {
        response: T[] | undefined;
        data: undefined;
        error: any;
        isExecuted: boolean;
        isLoading: boolean;
        isFinished: boolean;
        isSuccess: boolean;
        execute: (...args: any[]) => Promise<T[] | undefined>;
        reset: () => void;
        onSuccess: (fn: (param_0: T[] | undefined, ...param: unknown[]) => void) => {
            off: () => void;
        };
        onError: EventHook<any>["on"];
        onFinally: EventHook["on"];
    };
    loading: vue.ComputedRef<boolean | undefined>;
};

export { type OptionsApi, type OptionsApiConfig, type OptionsApiRequest, useOptionsApi };