declare module 'openapi-typescript-fetch/fetcher' {
  import { CreateFetch, FetchConfig, Middleware, OpenapiPaths } from 'openapi-typescript-fetch/types';
  export const Fetcher: {
      for: <Paths extends OpenapiPaths<Paths>>() => {
          configure: (config: FetchConfig) => void;
          use: (mw: Middleware) => number;
          path: <P extends keyof Paths>(path: P) => {
              method: <M extends keyof Paths[P]>(method: M) => {
                  create: CreateFetch<M, Paths[P][M]>;
              };
          };
      };
  };

}
declare module 'openapi-typescript-fetch/index' {
  import { Fetcher } from 'openapi-typescript-fetch/fetcher';
  import { arrayRequestBody } from 'openapi-typescript-fetch/utils';
  import type { ApiResponse, FetchArgType, FetchReturnType, FetchErrorType, Middleware, OpArgType, OpErrorType, OpDefaultReturnType, OpReturnType, TypedFetch } from 'openapi-typescript-fetch/types';
  import { ApiError } from 'openapi-typescript-fetch/types';
  export type { OpArgType, OpErrorType, OpDefaultReturnType, OpReturnType, FetchArgType, FetchReturnType, FetchErrorType, ApiResponse, Middleware, TypedFetch, };
  export { Fetcher, ApiError, arrayRequestBody };

}
declare module 'openapi-typescript-fetch/types' {
  export type Method = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'options';
  export type OpenapiPaths<Paths> = {
      [P in keyof Paths]: {
          [M in Method]?: unknown;
      };
  };
  type NonNever<T> = [T] extends [never | undefined] ? unknown : T;
  export type OpArgType<OP> = OP extends {
      parameters?: {
          path?: infer P;
          query?: infer Q;
          body?: infer B;
          header?: unknown;
          cookie?: unknown;
      };
      requestBody?: {
          content: {
              'application/json': infer RB;
          };
      };
  } ? NonNever<P> & NonNever<Q> & (B extends Record<string, unknown> ? NonNever<B[keyof B]> : unknown) & NonNever<RB> : Record<string, never>;
  type OpResponseTypes<OP> = OP extends {
      responses: infer R;
  } ? {
      [S in keyof R]: R[S] extends {
          schema?: infer S;
      } ? S : R[S] extends {
          content: {
              'application/json': infer C;
          };
      } ? C : S extends 'default' ? R[S] : unknown;
  } : never;
  type _OpReturnType<T> = 200 extends keyof T ? T[200] : 201 extends keyof T ? T[201] : 204 extends keyof T ? T[204] : 'default' extends keyof T ? T['default'] : unknown;
  export type OpReturnType<OP> = _OpReturnType<OpResponseTypes<OP>>;
  type _OpDefaultReturnType<T> = 'default' extends keyof T ? T['default'] : unknown;
  export type OpDefaultReturnType<OP> = _OpDefaultReturnType<OpResponseTypes<OP>>;
  const never: unique symbol;
  type _OpErrorType<T> = {
      [S in Exclude<keyof T, 200 | 201 | 204>]: {
          status: S extends 'default' ? typeof never : S;
          data: T[S];
      };
  }[Exclude<keyof T, 200 | 201 | 204>];
  type Coalesce<T, D> = [T] extends [never] ? D : T;
  export type OpErrorType<OP> = Coalesce<_OpErrorType<OpResponseTypes<OP>>, {
      status: number;
      data: any;
  }>;
  export type CustomRequestInit = Omit<RequestInit, 'headers'> & {
      readonly headers: Headers;
  };
  export type Fetch = (url: string, init: CustomRequestInit) => Promise<ApiResponse>;
  export type _TypedFetch<OP> = (arg: OpArgType<OP>, init?: RequestInit & {
      baseUrl?: string;
  }) => Promise<ApiResponse<OpReturnType<OP>>>;
  export type TypedFetch<OP> = _TypedFetch<OP> & {
      Error: new (error: ApiError) => ApiError & {
          getActualType: () => OpErrorType<OP>;
      };
  };
  export type FetchArgType<F> = F extends TypedFetch<infer OP> ? OpArgType<OP> : never;
  export type FetchReturnType<F> = F extends TypedFetch<infer OP> ? OpReturnType<OP> : never;
  export type FetchErrorType<F> = F extends TypedFetch<infer OP> ? OpErrorType<OP> : never;
  type _CreateFetch<OP, Q = never> = [Q] extends [never] ? () => TypedFetch<OP> : (query: Q) => TypedFetch<OP>;
  export type CreateFetch<M, OP> = M extends 'post' | 'put' | 'patch' | 'delete' ? OP extends {
      parameters: {
          query: infer Q;
      };
  } ? _CreateFetch<OP, {
      [K in keyof Q]: true | 1;
  }> : _CreateFetch<OP> : _CreateFetch<OP>;
  export type Middleware = (url: string, init: CustomRequestInit, next: Fetch) => Promise<ApiResponse>;
  export type FetchConfig = {
      baseUrl?: string | (() => string);
      init?: RequestInit;
      use?: Middleware[];
  };
  export type Request = {
      baseUrl: string;
      method: Method;
      path: string;
      queryParams: string[];
      payload: any;
      init?: RequestInit;
      fetch: Fetch;
  };
  export type ApiResponse<R = any> = {
      readonly headers: Headers;
      readonly url: string;
      readonly ok: boolean;
      readonly status: number;
      readonly statusText: string;
      readonly data: R;
  };
  export class ApiError extends Error {
      readonly headers: Headers;
      readonly url: string;
      readonly status: number;
      readonly statusText: string;
      readonly data: any;
      constructor(response: Omit<ApiResponse, 'ok'>);
  }
  export {};

}
declare module 'openapi-typescript-fetch/utils' {
  /**
   * Helper to merge params when request body is an array
   */
  export function arrayRequestBody<T, O>(array: T[], params?: O): T[] & O;

}
declare module 'openapi-typescript-fetch' {
  import main = require('openapi-typescript-fetch/index');
  export = main;
}