import type { Context, DefArgument, DefResult, Definitions, Request } from './shared';
export { Request };
type InvokePayload<Argument> = {
    call: {
        functionKey: string;
        payload?: Argument;
        jobId?: string;
    };
    context: Context;
};
export type Response = {
    [key: string]: any;
} | string | void;
export type ResolverFunction<Argument = any, Result = Response> = (request: Request<Argument>) => Promise<Result> | Result;
type DefinitionsHandler = (payload: InvokePayload<unknown>, backendRuntimePayload?: Record<string, any>) => Promise<unknown>;
export default class Resolver {
    private functions;
    constructor();
    define(functionKey: string, cb: ResolverFunction<any, any>): this;
    /**
     * Defines a resolver with explicit payload and return types.
     *
     * The first generic is the payload shape and the second generic is the return type.
     *
     * @example
     * type Payload = { name: string };
     * type Response = { message: string };
     * resolver.define<Payload, Response>('greet', ({ payload }) => ({
     *   message: `Hello ${payload.name}`
     * }));
     */
    define<Payload, Result = Response>(functionKey: string, cb: ResolverFunction<Payload, Result>): this;
    /**
     * Defines a resolver using the return-only generic form.
     *
     * The single type argument is the return type.
     *
     * @example
     * type Response = { message: string };
     * resolver.define<Response>('greet', () => ({ message: 'ok' }));
     */
    define<Result = Response>(functionKey: string, cb: ResolverFunction<any, Result>): this;
    private getFunction;
    private sanitizeObject;
    getDefinitions(): DefinitionsHandler;
}
/**
 * Given a type specialising Definitions shared between frontend and backend,
 * Handlers will return a type for a record of resolver functions that are
 * needed to implement this on the backend.
 */
export type Handlers<D extends Definitions> = {
    [Def in keyof D & string]: ResolverFunction<DefArgument<D, Def>, DefResult<D, Def>>;
};
/**
 * Creates resolver definitions corresponding to a given Definitions type.
 *
 * @param handlers Resolver functions implementing the definitions
 * @returns Resolver definitions
 */
export declare function makeResolver<D extends Definitions>(handlers: Handlers<D>): DefinitionsHandler;
//# sourceMappingURL=index.d.ts.map