import { HttpHeaders, HttpClient, HttpResourceOptions, HttpResourceRef } from '@angular/common/http';
import { Observable } from 'rxjs';
import { MediaType, Readable, SuccessResponse, ResponseObjectMap, RequiredKeysOf, Writable, OperationRequestBodyContent, IsOperationRequestBodyOptional, HttpMethod, PathsWithMethod, FilterKeys } from 'openapi-typescript-helpers';
import { Injector } from '@angular/core';

type HttpClientResponse<T extends Record<string | number, any>, Media extends MediaType> = Readable<SuccessResponse<ResponseObjectMap<T>, Media>>;

type QuerySerializer<T> = (query: T extends {
    parameters: any;
} ? NonNullable<T['parameters']['query']> : Record<string, unknown>) => string;

/** @see https://swagger.io/docs/specification/serialization/#query */
interface QuerySerializerOptions {
    /** Set serialization for arrays. @see https://swagger.io/docs/specification/serialization/#query */
    array?: {
        /** default: "form" */
        style: 'form' | 'spaceDelimited' | 'pipeDelimited';
        /** default: true */
        explode: boolean;
    };
    /** Set serialization for objects. @see https://swagger.io/docs/specification/serialization/#query */
    object?: {
        /** default: "deepObject" */
        style: 'form' | 'deepObject';
        /** default: true */
        explode: boolean;
    };
    /**
     * The `allowReserved` keyword specifies whether the reserved characters
     * `:/?#[]@!$&'()*+,;=` in parameter values are allowed to be sent as they
     * are, or should be percent-encoded. By default, allowReserved is `false`,
     * and reserved characters are percent-encoded.
     * @see https://swagger.io/docs/specification/serialization/#query
     */
    allowReserved?: boolean;
}

interface DefaultParamsOption {
    params?: {
        query?: Record<string, unknown>;
    };
}

type ParamsOption<T> = T extends {
    parameters: any;
} ? RequiredKeysOf<T['parameters']> extends never ? {
    params?: T['parameters'];
} : {
    params: T['parameters'];
} : DefaultParamsOption;

type MultipartFormData<T> = T extends {
    requestBody?: infer RequestBody;
} ? NonNullable<RequestBody> extends {
    content: infer Content;
} ? 'multipart/form-data' extends keyof Content ? FormData : never : never : never;
type SerializedStringBody<T> = Extract<NonNullable<OperationRequestBodyContent<T>>, string> extends never ? never : string;
type RequestBody<T> = OperationRequestBodyContent<T> | MultipartFormData<T> | SerializedStringBody<T>;
type RequestBodyOption<T> = Writable<OperationRequestBodyContent<T>> extends never ? {
    body?: never;
} : IsOperationRequestBodyOptional<T> extends true ? {
    body?: Writable<RequestBody<T>>;
} : {
    body: Writable<RequestBody<T>>;
};

type RequestOptions<T> = ParamsOption<T> & RequestBodyOption<T> & {
    baseUrl?: string;
    headers?: HttpHeaders;
    querySerializer?: QuerySerializer<unknown> | QuerySerializerOptions;
};

/** This type helper makes the 2nd function param required if params/requestBody are required; otherwise, optional */
type MaybeOptionalInit<Params, Location extends keyof Params> = RequiredKeysOf<RequestOptions<FilterKeys<Params, Location>>> extends never ? RequestOptions<FilterKeys<Params, Location>> | undefined : RequestOptions<FilterKeys<Params, Location>>;
type InitParam$1<Init> = RequiredKeysOf<Init> extends never ? [(Init & Record<string, unknown>)?] : [Init & Record<string, unknown>];
type ClientMethod<Paths extends Record<string, Record<HttpMethod, any>>, Method extends HttpMethod, Media extends MediaType> = <Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<Paths[Path], Method>>(url: Path, ...init: InitParam$1<Init>) => Observable<HttpClientResponse<Paths[Path][Method], Media>>;
type ClientRequestMethod<Paths extends Record<string, Record<HttpMethod, any>>, Media extends MediaType> = <Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<Paths[Path], Method>>(method: Method, url: Path, ...init: InitParam$1<Init>) => Observable<HttpClientResponse<Paths[Path][Method], Media>>;
interface OpenAPIHttpClientOptions {
    baseUrl: string;
    querySerializer?: QuerySerializer<unknown> | QuerySerializerOptions;
}
declare function createOpenAPIHttpClient<Paths extends Record<string, any>>(httpClient: HttpClient, options: OpenAPIHttpClientOptions): OpenAPIHttpClient<Paths, `${string}/${string}`>;
declare class OpenAPIHttpClient<Paths extends Record<string, any>, Media extends MediaType = MediaType> {
    private http;
    private readonly baseUrl;
    private readonly querySerializer?;
    constructor(http: HttpClient, { baseUrl, querySerializer }: OpenAPIHttpClientOptions);
    core<Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<Paths[Path], Method>, Method extends HttpMethod>(method: Method, path: Path, options: InitParam$1<Init>): Observable<HttpClientResponse<Paths[Path], Media>>;
    request: ClientRequestMethod<Paths, Media>;
    get: ClientMethod<Paths, 'get', Media>;
    put: ClientMethod<Paths, 'put', Media>;
    post: ClientMethod<Paths, 'post', Media>;
    delete: ClientMethod<Paths, 'delete', Media>;
    options: ClientMethod<Paths, 'options', Media>;
    head: ClientMethod<Paths, 'head', Media>;
    patch: ClientMethod<Paths, 'patch', Media>;
}

/**
 * Strongly-typed OpenAPI Resource builder on top of Angular's httpResource.
 *
 * - Preserves dfx-openapi type inference (paths, params, body, and typed responses)
 * - Reactive by design: pass a function that reads signals; when those signals change,
 *   the resource re-fetches.
 * - Supports per-resource httpResource options via `http` field.
 */

interface OpenAPIResourceOptions {
    baseUrl: string;
    querySerializer?: QuerySerializer<unknown> | QuerySerializerOptions;
}
/**
 * Allow per-resource httpResource options via `http` property, while preserving
 * OpenAPI request options shape.
 */
type WithHttpOptions<Init, TResult, TRaw> = Init & {
    http?: HttpResourceOptions<TResult, TRaw>;
};
/**
 * Make the single `init` argument optionally present based on whether params/body
 * are required for the specific operation. The init can be either a plain object
 * or a getter function (() => object | undefined) for reactivity.
 */
type InitGetterOrValue<Init> = Init | (() => Init | undefined);
type InitParam<Init> = RequiredKeysOf<Init> extends never ? [InitGetterOrValue<Init>?] : [InitGetterOrValue<Init>];
/**
 * Factory: create a typed OpenAPI Resource builder.
 * Use this once per API (e.g. per `Paths`) and reuse it throughout your app.
 */
declare function createOpenAPIResource<Paths extends Record<string, any>, Media extends MediaType = MediaType>(options: OpenAPIResourceOptions, injector?: Injector): OpenAPIResource<Paths, Media>;
/**
 * OpenAPIResource returns HttpResourceRefs that refetch reactively when any
 * signals used inside your init getter (path/params/body) change.
 */
declare class OpenAPIResource<Paths extends Record<string, any>, Media extends MediaType = MediaType> {
    private injector;
    private readonly baseUrl;
    private readonly querySerializer?;
    constructor({ baseUrl, querySerializer }: OpenAPIResourceOptions, injector: Injector);
    /**
     * Core resource method. Prefer using the per-method helpers below.
     *
     * Example:
     * const users = api.request('get', () => '/users', () => ({
     *   params: { query: { page: pageSignal() } },
     *   http: { defaultValue: [] }
     * }));
     */
    core<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>>(method: Method, path: () => Path | undefined, ...initParam: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], Method>>, HttpClientResponse<Paths[Path][Method], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path][Method], Media> | undefined>;
    request<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>>(method: Method, path: () => Path | undefined, ...init: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], Method>>, HttpClientResponse<Paths[Path][Method], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path][Method], Media> | undefined>;
    get<Path extends PathsWithMethod<Paths, 'get'>>(path: () => Path | undefined, ...init: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], 'get'>>, HttpClientResponse<Paths[Path]['get'], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path]['get'], Media> | undefined>;
    put<Path extends PathsWithMethod<Paths, 'put'>>(path: () => Path | undefined, ...init: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], 'put'>>, HttpClientResponse<Paths[Path]['put'], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path]['put'], Media> | undefined>;
    post<Path extends PathsWithMethod<Paths, 'post'>>(path: () => Path | undefined, ...init: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], 'post'>>, HttpClientResponse<Paths[Path]['post'], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path]['post'], Media> | undefined>;
    delete<Path extends PathsWithMethod<Paths, 'delete'>>(path: () => Path | undefined, ...init: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], 'delete'>>, HttpClientResponse<Paths[Path]['delete'], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path]['delete'], Media> | undefined>;
    options<Path extends PathsWithMethod<Paths, 'options'>>(path: () => Path | undefined, ...init: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], 'options'>>, HttpClientResponse<Paths[Path]['options'], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path]['options'], Media> | undefined>;
    head<Path extends PathsWithMethod<Paths, 'head'>>(path: () => Path | undefined, ...init: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], 'head'>>, HttpClientResponse<Paths[Path]['head'], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path]['head'], Media> | undefined>;
    patch<Path extends PathsWithMethod<Paths, 'patch'>>(path: () => Path | undefined, ...init: InitParam<WithHttpOptions<RequestOptions<FilterKeys<Paths[Path], 'patch'>>, HttpClientResponse<Paths[Path]['patch'], Media>, unknown>>): HttpResourceRef<HttpClientResponse<Paths[Path]['patch'], Media> | undefined>;
}

export { OpenAPIHttpClient, OpenAPIResource, createOpenAPIHttpClient, createOpenAPIResource };
export type { ClientRequestMethod, OpenAPIHttpClientOptions, OpenAPIResourceOptions };