import { HttpMethod } from 'openapi-typescript-helpers';
import { RequiredKeys } from 'ts-essentials';
import { paths as projectPaths } from './openapi/project-api';
/**
 * Optional parameter that can be passed to the client methods. It allows
 * overriding the access token or project ID, and setting various headers,
 * such as 'Content-Type'.
 */
export interface ZapEHRClientRequest {
    /**
     * The access token to use for the request. If not provided, the access token from `zapehr.init()` will be used.
     */
    accessToken?: string;
    /**
     * The project ID to use for the request. If not provided, the project ID from `zapehr.init()` will be used.
     */
    projectId?: string;
    /**
     * The value of the 'Content-Type' header to use for the request.
     */
    contentType?: string;
}
export interface InternalClientRequest extends ZapEHRClientRequest {
    ifMatch?: string;
}
export declare function projectClient<Path extends keyof projectPaths, PathMethods extends Extract<keyof projectPaths[Path], HttpMethod>>(path: Path): Client<Path, PathMethods>;
type FetcherResponse = any;
export declare function fetcher(baseUrlThunk: () => string, path: string, methodParam: string): (params?: Record<string, unknown> | [any], request?: InternalClientRequest) => Promise<FetcherResponse>;
/**
 * Adds params to a URLSearchParams object in such a way as to preserve array values.
 * @param params params
 * @param search URLSearchParams object
 */
export declare function addParamsToSearch(params: Record<string, unknown>, search: URLSearchParams): void;
/** Helper Types **/
type AllPaths = projectPaths;
type Client<Path extends keyof AllPaths, Method extends Extract<keyof AllPaths[Path], HttpMethod>> = {
    [M in Method]: ClientMethod<Path, M>;
};
type ClientMethod<Path extends keyof AllPaths, Method extends Extract<keyof AllPaths[Path], HttpMethod>> = BodyParams<Path, Method> extends never ? PathParams<Path, Method> extends never ? (request?: ZapEHRClientRequest) => Promise<PathResponse<Path, Method>> : RequiredPathParams<Path, Method> extends never ? (params?: PathParams<Path, Method>, request?: ZapEHRClientRequest) => Promise<PathResponse<Path, Method>> : (params: PathParams<Path, Method>, request?: ZapEHRClientRequest) => Promise<PathResponse<Path, Method>> : PathParams<Path, Method> extends never ? (params: BodyParams<Path, Method>, request?: ZapEHRClientRequest) => Promise<PathResponse<Path, Method>> : (params: Flatten<BodyParams<Path, Method> & PathParams<Path, Method>>, request?: ZapEHRClientRequest) => Promise<PathResponse<Path, Method>>;
type PathParams<Path extends keyof AllPaths, Method extends HttpMethod> = AllPaths[Path] extends {
    [M in Method]: {
        parameters: {
            path?: infer P;
            query?: infer Q;
        };
    };
} ? P & Q : never;
type RequiredPathParams<Path extends keyof AllPaths, Method extends HttpMethod> = RequiredKeys<PathParams<Path, Method>> extends never ? never : PathParams<Path, Method>;
type BodyParams<Path extends keyof AllPaths, Method extends HttpMethod> = AllPaths[Path] extends {
    [M in Method]: any;
} ? AllPaths[Path][Method] extends {
    requestBody?: {
        content: {
            'application/json': infer B;
        };
    };
} ? B : never : never;
type PathResponseType<M> = M extends {
    responses: infer Responses;
} ? {
    [Response in keyof Responses]: Responses[Response] extends {
        content: {
            'application/json': infer Content;
        };
    } ? Content : Response extends 'default' ? Responses[Response] : never;
} : never;
type PathResponse<Path extends keyof AllPaths, Method extends Extract<keyof AllPaths[Path], HttpMethod>> = AllPaths[Path] extends {
    [M in Method]: {
        responses: {
            200: Record<string, unknown>;
        };
    };
} ? PathResponseType<AllPaths[Path][Method]>[200] : never;
type Flatten<T> = {
    [K in keyof T]: T[K];
} & {};
export {};