import * as p_ti from "../../interface/transformer.js";
import * as p_di from "../../schema.js";
import { type Abort } from "../Abort.js";
import { type Query_Result } from "../../interface/__internal/query/Query_Result.js";
export type Query_Callback<Output extends p_di.Value, Error extends p_di.Value, Input extends p_di.Value> = ($: Input) => Query_Result<Output, Error>;
/**
 * this function contains the body in which the async value or error is executed
 * after the execution, either the on_result or on_error callback will be called
 * @param on_result the callback to call when a value is produced
 * @param on_error the callback to call when an error is produced
 */
type Executer<Output extends p_di.Value, Error extends p_di.Value> = (on_result: ($: Output) => undefined, on_error: ($: Error) => undefined) => undefined;
type Group_Result<T> = T extends Query_Result<infer Output, any> ? Output : never;
type Group_Results<T extends readonly Query_Result<p_di.Value, p_di.Value>[]> = {
    [K in keyof T]: Group_Result<T[K]>;
} & p_di.Value;
export declare class Super_Query_Result_Class<Output extends p_di.Value, Error extends p_di.Value> {
    __extract_data: Executer<Output, Error>;
    constructor(executer: Executer<Output, Error>);
    dictionary<Entry extends p_di.Value, Result extends p_di.Value, Entry_Error extends p_di.Value>(dictionary_getter: ($: Output) => p_di.Dictionary<Entry>, map_entry: ($: Entry, id: string) => Query_Result<Result, Entry_Error>, aggregate_errors: p_ti.Transformer<p_di.Dictionary<Entry_Error>, Error>): Query_Result<p_di.Dictionary<Result>, Error>;
    group<Entry_Error extends p_di.Value, const T extends readonly Query_Result<p_di.Value, Entry_Error>[]>(group_getter: ($: Output) => [...T], aggregate_errors: p_ti.Transformer<p_di.List<Entry_Error>, Error>): Query_Result<Group_Results<T>, Error>;
    direct_error($: Error): Query_Result<never, Error>;
    direct_result<Result extends p_di.Value>(result: Result): Query_Result<Result, never>;
    observe_behavior<Preparation_Result extends p_di.Value, Preparation_Error extends p_di.Value, Target_Outcome extends p_di.Value>(result_getter: ($: Output) => Query_Result<Preparation_Result, Preparation_Error>, handlers: {
        success: (result: Preparation_Result) => Query_Result<Target_Outcome, Error>;
        error: (error: Preparation_Error) => Query_Result<Target_Outcome, Error>;
    }): Query_Result<Target_Outcome, Error>;
    query<New_Output extends p_di.Value>(queryer: Query_Callback<New_Output, Error, Output>): Super_Query_Result_Class<New_Output, Error>;
    refine<New_Output extends p_di.Value>(callback: ($: Output, abort: Abort<Error>) => New_Output): Super_Query_Result_Class<New_Output, Error>;
    rework_error_temp<New_Error extends p_di.Value, Rework_Error extends p_di.Value>(error_reworker: Query_Callback<New_Error, Rework_Error, Error>, rework_error_transformer: p_ti.Transformer<Rework_Error, New_Error>): Super_Query_Result_Class<Output, New_Error>;
    temp_expression<New_Output extends p_di.Value>(callback: ($: Output) => Query_Result<New_Output, Error>): Super_Query_Result_Class<New_Output, Error>;
    transform<New_Output extends p_di.Value>(transformer: p_ti.Transformer<Output, New_Output>): Super_Query_Result_Class<New_Output, Error>;
    try_and_catch<New_Output extends p_di.Value, Inner_Error extends p_di.Value>(try_: (e: Super_Query_Result_Class<Output, Inner_Error>) => Query_Result<New_Output, Inner_Error>, catch_: (e: Inner_Error) => Query_Result<New_Output, Error>): Super_Query_Result_Class<New_Output, Error>;
}
export default function <T extends p_di.Value, E extends p_di.Value>(query_result: Query_Result<T, E>): Super_Query_Result_Class<T, E>;
export {};