import { IActionPayload } from './BaseAction';
import { Metas, MetasLoading, IMetaAction, Meta } from '../reducers/MetaReducer';
import { State, StateReturn } from '../models/BaseModel';
import { HTTP_STATUS_CODE } from '../utils/httpStatusCode';
import { HttpServiceBuilder } from '../services/HttpServiceBuilder';
import { METHOD } from '../utils/method';
import { ThrottleKeyOption, BaseHttpService } from '../services/BaseHttpService';
import { BaseAsyncAction } from './BaseAsyncAction';
export interface Types {
    prepare: string;
    success: string;
    fail: string;
}
export interface IBaseRequestAction<Data = any, Response = any, Payload = any, Type = Types> extends IActionPayload<Payload, Type>, IMetaAction {
    method: METHOD;
    uri: string;
    body: Record<string, any>;
    query: Record<string, any>;
    successText: string;
    failText: string;
    hideError: boolean | ((response: IResponseAction<unknown, Payload>) => boolean);
    requestOptions: object;
    modelName: string;
    throttle: {
        enable: boolean;
        duration: number;
        key: string;
        transfer: ThrottleKeyOption['transfer'];
    };
    onPrepare?: (state: State<Data>, action: IActionPayload<Payload>) => StateReturn<Data>;
    afterPrepare?: (action: IActionPayload<Payload>) => void;
    afterPrepareDuration?: number;
    onSuccess?: (state: State<Data>, action: IResponseAction<Response, Payload>) => StateReturn<Data>;
    afterSuccess?: (action: IResponseAction<Response, Payload>) => void;
    afterSuccessDuration?: number;
    onFail?: (state: State<Data>, action: IResponseAction<unknown, Payload>) => StateReturn<Data>;
    afterFail?: (action: IResponseAction<unknown, Payload>) => void;
    afterFailDuration?: number;
}
export interface HttpTransform {
    httpStatus?: HTTP_STATUS_CODE;
    message?: string;
    businessCode?: string;
}
export interface IResponseAction<Response = any, Payload = any> extends IActionPayload<Payload>, HttpTransform {
    response: Response;
}
export interface RequestPrepareAction<Data = any, Response = any, Payload = any> extends IBaseRequestAction<Data, Response, Payload, string> {
    loading: boolean;
    effect: IBaseRequestAction<Data, Response, Payload>['onPrepare'];
    after: IBaseRequestAction<Data, Response, Payload>['afterPrepare'];
    afterDuration: IBaseRequestAction<Data, Response, Payload>['afterPrepareDuration'];
}
export interface RequestSuccessAction<Data = any, Response = any, Payload = any> extends IBaseRequestAction<Data, Response, Payload, string>, IResponseAction<Response, Payload> {
    loading: boolean;
    effect: IBaseRequestAction<Data, Response, Payload, Payload>['onSuccess'];
    after: IBaseRequestAction<Data, Response, Payload, Payload>['afterSuccess'];
    afterDuration: IBaseRequestAction<Data, Response, Payload>['afterSuccessDuration'];
}
export interface RequestFailAction<Data = any, Response = any, Payload = any> extends IBaseRequestAction<Data, Response, Payload, string>, IResponseAction<unknown, Payload> {
    loading: boolean;
    effect: IBaseRequestAction<Data, Response, Payload, Payload>['onFail'];
    after: IBaseRequestAction<Data, Response, Payload, Payload>['afterFail'];
    afterDuration: IBaseRequestAction<Data, Response, Payload>['afterFailDuration'];
}
export interface RequestSubscriber {
    when: string;
    duration?: number;
}
export interface RequestPrepareSubscriber<CustomData, Payload> extends RequestSubscriber {
    then?: (state: State<CustomData>, action: IActionPayload<Payload>) => StateReturn<CustomData>;
    after?: (action: IActionPayload<Payload>) => void;
}
export interface RequestSuccessSubscriber<CustomData, Response, Payload> extends RequestSubscriber {
    then?: (state: State<CustomData>, action: IResponseAction<Response, Payload>) => StateReturn<CustomData>;
    after?: (action: IResponseAction<Response, Payload>) => void;
}
export interface RequestFailSubscriber<CustomData, Payload> extends RequestSubscriber {
    then?: (state: State<CustomData>, action: IResponseAction<unknown, Payload>) => StateReturn<CustomData>;
    after?: (action: IResponseAction<unknown, Payload>) => void;
}
export declare class BaseRequestAction<Data, Builder extends (...args: any[]) => HttpServiceBuilder<Data, Response, Payload, any, M>, Response, Payload, M> extends BaseAsyncAction<Data> {
    protected readonly builder: Builder;
    protected loadingsCache?: [Metas, MetasLoading<any>];
    protected readonly service: BaseHttpService<any, any>;
    constructor(builder: Builder, service: BaseHttpService<any, any>, fromSubClass?: boolean);
    /**
     * Clear throttle cache for this action
     */
    clearThrottle(): void;
    /**
     * Information collected from service
     *
     * ```javascript
     * class TestModel extends Model {
     *   getUser = $api.action(() => {
     *     return this
     *      .get('/api')
     *      .onSuccess(() => {})
     *   });
     * }
     *
     * const testModel = new TestModel();
     *
     * // Get information
     * testModel.getUser.meta.httpStatus;
     * // Dispatch action
     * testModel.getUser();
     * ```
     */
    get meta(): Meta;
    /**
     * @see get meta()
     *
     * ```javascript
     * testModel.getUser.loading;
     * ```
     */
    get loading(): boolean;
    /**
     * Information collected from service.
     * ```javascript
     * class TestModel extends Model {
     *   getUser = $api.action((id: number) => {
     *     return this
     *      .get('/api')
     *      .metas(id)
     *      .onSuccess(() => {})
     *   });
     * }
     *
     * const testModel = new TestModel();
     *
     * // Get information
     * testModel.getUser.metas.pick(1).httpStatus;
     * // Dispatch action
     * testModel.getUser(1);
     * ```
     */
    get metas(): Metas<M>;
    /**
     * @see get metas()
     *
     * ```javascript
     * testModel.getUser.loadings.pick(1);
     * ```
     */
    get loadings(): MetasLoading<M>;
    /**
     * For model.subscriptions()
     */
    onSuccess<CustomData>(changeState: NonNullable<RequestSuccessSubscriber<CustomData, Response, Payload>['then']>): RequestSuccessSubscriber<CustomData, Response, Payload>;
    /**
     * For model.subscriptions()
     */
    afterSuccess<CustomData>(callback: NonNullable<RequestSuccessSubscriber<CustomData, Response, Payload>['after']>, duration?: number): RequestSuccessSubscriber<CustomData, Response, Payload>;
    /**
     * For model.subscriptions()
     */
    onPrepare<CustomData>(changeState: NonNullable<RequestPrepareSubscriber<CustomData, Payload>['then']>): RequestPrepareSubscriber<CustomData, Payload>;
    /**
     * For model.subscriptions()
     */
    afterPrepare<CustomData>(callback: NonNullable<RequestPrepareSubscriber<CustomData, Payload>['after']>, duration?: number): RequestPrepareSubscriber<CustomData, Payload>;
    /**
     * For model.subscriptions()
     */
    onFail<CustomData>(changeState: NonNullable<RequestFailSubscriber<CustomData, Payload>['then']>): RequestFailSubscriber<CustomData, Payload>;
    /**
     * For model.subscriptions()
     */
    afterFail<CustomData>(callback: NonNullable<RequestFailSubscriber<CustomData, Payload>['after']>, duration?: number): RequestFailSubscriber<CustomData, Payload>;
    protected getLoadingHandler(metas: Metas): MetasLoading<any>;
    /**
     * @override
     */
    protected methods(): string[];
    /**
     * @override
     */
    protected getters(): string[];
    /**
     * @implements
     */
    protected action(): Function;
}