import type { Qs } from './utils/qs';
import type { GetPathValue, GetPath } from './utils/get';
import type { Options as PrettierOptions } from 'prettier';
export { PrettierOptions };
export type OpenApiComponentSchemas = Record<string, OpenApiSchema>;
type BasicType = 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'enums' | 'null' | 'any';
export type OpenApiSchema = {
    type: 'ref';
    ref: string;
} | {
    type: BasicType | BasicType[];
    description: string;
    required?: string[];
    enum?: any[];
    properties?: Record<string, OpenApiSchema>;
    additionalProperties?: boolean | OpenApiSchema;
    items?: OpenApiSchema;
    default?: any;
    nullable?: boolean;
};
export type RefType = {
    type: 'ref';
    ref: string;
};
export type BaseContentType = {
    type: 'object';
    contentType: string;
    description: string;
    schema: OpenApiSchema;
};
export type OpenApiResponse = RefType | (BaseContentType & {});
export type OpenApiRequestBody = RefType | (BaseContentType & {
    required: boolean;
});
export type OpenApiComponentResponses = Record<string, OpenApiResponse>;
export type OpenApiComponentRequestBodies = Record<string, OpenApiRequestBody>;
export type OpenApiComponentParameters = Record<string, OpenApiParameter>;
export type OpenApiParameter = OpenApiParameterObject | OpenApiParameterRef;
export type OpenApiParameterObject = {
    type: 'object';
    in: 'query' | 'header' | 'path' | 'cookie';
    name: string;
    description: string;
    required: boolean;
    schema: OpenApiSchema;
};
export type OpenApiParameterRef = {
    type: 'ref';
    ref: string;
};
export type OpenApiComponents = {
    schemas: OpenApiComponentSchemas;
    parameters: OpenApiComponentParameters;
    requestBodies: OpenApiComponentRequestBodies;
    responses: OpenApiComponentResponses;
};
export type OpenApiPaths = Record<string, OpenApiPath>;
export type OpenApiPath = {
    path: string;
    description: string;
    methods: Record<string, {
        description: string;
        parameters?: OpenApiParameter[];
        requestBody?: OpenApiRequestBody;
        response: OpenApiResponse;
    }>;
};
export type OpenApiDefine = {
    components: OpenApiComponents;
    paths: OpenApiPaths;
};
export type ApiCommandArgsType<Command> = Command extends ApiCommand<any, any, any, infer Args, any, any> ? Args : never;
export type ApiCommandResType<Command> = Command extends ApiCommand<any, any, any, any, infer Res, any> ? Res : never;
export type ApiCommandSelectedResType<Command> = Command extends ApiCommand<any, any, any, any, any, infer Selector> ? Selector extends string ? Selector extends GetPath<ApiCommandResType<Command>> ? GetPathValue<ApiCommandResType<Command>, Selector> : unknown : ApiCommandResType<Command> : never;
export interface ApiClient<Group extends string> {
    send<Args, Res, Selector extends string | void, Command extends ApiCommand<Group, any, any, Args, Res, Selector>>(command: Command): Promise<ApiCommandSelectedResType<Command>>;
    sendAll<Args, Res, Selector extends string | void, Command extends ApiCommand<Group, any, any, Args, Res, Selector>, Commands extends [Command, ...Command[]] | {
        [key: string]: Command;
    }>(commands: Commands): Promise<{
        [P in keyof Commands]: ApiCommandSelectedResType<Commands[P]>;
    }>;
}
export type Get<T, K> = K extends keyof T ? T[K] : any;
export type ApiCommand<Group extends string = string, Path extends string = string, Method extends string = string, Args extends any = any, Res extends any = any, Selector extends string | void = any> = {
    readonly method: `${Group}::${Path}::${Method}`;
    readonly args: Args;
    readonly mock?: Res;
    readonly selector: Selector;
};
export type ApiConfig<K extends string = string> = {
    schemas: {
        [key in K]: string | {
            input: string;
            selector?: (o: any) => any;
        };
    };
    outDir: string;
    prettierConfig?: string | PrettierOptions;
};
export type ApiConfigFn<K extends string = string> = () => ApiConfig<K> | Promise<ApiConfig<K>>;
export type ApiClientOptions<K extends string | symbol | number> = {
    remote: {
        [group in K]: ApiClientRemoteOptions;
    };
};
export type ApiClientRemoteOptions = {
    endpoint: string;
    override?: {
        qs?: Qs;
        fetch?: typeof fetch;
        Request?: typeof Request;
    };
    handleRequest?: (request: Request) => Request | Promise<Request>;
    handleResponse?: (response: Response) => Response | Promise<Response>;
    validateData?: (url: string, data: any) => void;
};
export interface OpenApiRequestBodyObject {
    contentType: string;
}
export interface OpenApiResponseObject {
    contentType: string;
}