export declare function makeRequest<returnType>(method: 'get' | 'post' | 'delete' | 'update', params: any, path: string): Promise<returnType & {
    usage: businessUseCaseUsage;
}>;
interface businessUseCaseUsage {
    [key: string | number]: Array<{
        type: string;
        call_count: number;
        total_cputime: number;
        total_time: number;
        estimated_time_to_regain_access: number;
    }>;
}
export type datetime = string;
export type int = number;
export type float = number;
export type bool = boolean;
export type map<A extends string | number | symbol = string, B = any> = Record<A, B>;
export type list<A extends any = any> = Array<A>;
export type uint = number;
export interface defaultParamsNodes {
    limit?: number;
    filtering?: {
        field: string;
        operator: "EQUAL" | "IN";
        value: string;
    }[];
    summary?: ReadonlyArray<"total_count" | string>;
}
export interface rootParams {
    readonly metadata?: true;
    readonly pretty?: boolean;
    readonly debug?: "all";
    readonly access_token: string;
}
export type rootParamsAnd<T extends ({
    fields?: {};
} | {}) = {
    fields?: {};
}> = rootParams & T;
type Params = rootParamsAnd<any>;
type FormatValue<T extends Primitive | Connection> = T extends Connection ? FormatParams4Input<T> : T extends Primitive ? true : never;
export type FormatParams4Input<T extends rootParamsAnd<any>> = Omit<T, 'fields'> & defaultParamsNodes & {
    fields?: {
        [key in keyof T['fields']]?: FormatValue<T['fields'][key]>;
    };
};
export type Primitive<T extends string | bool | datetime | int | float | map | list | uint = any> = T;
export type Field<T extends Primitive | {}> = T;
export type Connection<T extends BaseConnection = BaseConnection> = T;
interface BaseConnection {
    fields?: {
        [key: string]: any;
    };
    summary?: ReadonlyArray<"total_count" | string>;
}
export interface paging {
    next?: string;
    cursors: {
        before: string;
        after: string;
    };
    getNext?: () => {};
}
type formatConnection<T, key, summary extends ReadonlyArray<string> | undefined> = key extends "picture" ? {
    data: T;
} : {
    data: T[];
    paging: paging;
} & (summary extends ReadonlyArray<string> ? {
    summary: {
        [key in summary[number]]: any;
    };
} : {});
type useKeysFromLeft<left, right> = {
    [key in keyof left]: left[key] extends Params ? formatConnection<useKeysFromLeft<left[key]['fields'], right[key]['fields']>, key, left[key]['summary']> : right[key];
};
type formatReturn<inParams extends FormatParams4Input<ogParams>, ogParams extends Params, left = inParams['fields'], right = ogParams['fields']> = useKeysFromLeft<left, right>;
export declare class BaseQuery {
    static get<inParams extends FormatParams4Input<ogParams>, ogParams extends Params, returnType = formatReturn<inParams, ogParams>>(params: inParams, path: string): Promise<returnType>;
    static delete<inParams extends FormatParams4Input<ogParams>, ogParams extends Params, returnType = formatReturn<inParams, ogParams>>(params: inParams, path: string): Promise<returnType>;
    static update<inParams extends FormatParams4Input<ogParams>, ogParams extends Params, returnType = formatReturn<inParams, ogParams>>(params: inParams, path: string): Promise<returnType>;
    static post<inParams extends FormatParams4Input<ogParams>, ogParams extends Params, returnType = formatReturn<inParams, ogParams>>(params: inParams, path: string): Promise<returnType>;
    id: string;
    constructor(id: string);
}
export {};