/// <reference types="node" />
import { ServerResponse, IncomingMessage } from 'http';

type Listener<T extends Array<unknown>> = (...args: T) => void;
declare class EventEmitter<
  E extends Record<string, Array<unknown>> = Record<never, []>,
> {
  private listenerMap;
  on<K extends keyof E>(key: K, listener: Listener<E[K]>): () => void;
  addListener<K extends keyof E>(key: K, listener: Listener<E[K]>): () => void;
  off<K extends keyof E>(key: K, listener: Listener<E[K]>): void;
  removeListener<K extends keyof E>(key: K, listener: Listener<E[K]>): void;
  emit<K extends keyof E>(key: K, ...args: E[K]): void;
}

type Headers$2 = Record<string, number | string | Array<string>>;
declare class Response$1 {
  private _super;
  req: Request$1 | undefined;
  constructor(httpRes: ServerResponse);
  writeHead(statusCode: number, statusReason: string, headers: Headers$2): void;
  write(data: Buffer | string): void;
  end(): void;
}

type Events$2 = {
  end: [];
};
declare class Request$1 extends EventEmitter<Events$2> {
  private _super;
  res: Response$1 | undefined;
  constructor(req: IncomingMessage);
  getMethod(): string;
  getURL(): string;
  getHeaders(): Record<string, string | string[]>;
  getRemoteAddress(): string | undefined;
  getReadStream(): NodeJS.ReadableStream;
  read(_bytes: number): void;
}

type RedirectType = 'html' | '301' | '302' | '303';
type Cookie = {
  value: string;
  domain?: string;
  path?: string;
  expires?: Date;
  httpOnly?: boolean;
  secure?: boolean;
};
declare class Response {
  private _super;
  private buffer;
  req: Request | undefined;
  constructor(res: Response$1);
  clear(type?: string, status?: string): void;
  status(status?: string | number): string | this;
  charset(charset?: string): string;
  headers<
    T extends
      | []
      | [name: string]
      | [name: string, value: string | null]
      | [Record<string, string>],
  >(
    ...args: T
  ): T extends []
    ? Record<string, string | Array<string>>
    : T extends [string]
    ? string | undefined
    : Response;
  write(data: unknown): void;
  contentType(type: string): void;
  cookies<
    T extends
      | []
      | [name: string]
      | [name: string, value: Cookie | string | null]
      | [Record<string, string | Cookie>],
  >(
    ...args: T
  ): T extends []
    ? Record<string, Cookie>
    : T extends [string]
    ? Cookie | undefined
    : Response;
  _prepHeaders(): void;
  _writeHead(): void;
  end(...args: Array<unknown>): void;
  die(...args: Array<unknown>): void;
  redirect(url: string, type?: RedirectType): void;
  htmlRedirect(url: string): void;
}

type Headers$1 = Record<string, string | Array<string>>;
type ParsedUrl = {
  raw: string;
  rawPath: string;
  path: string;
  search: string;
  qs: string;
};
type UrlPartName = keyof ParsedUrl;
type Events$1 = {
  'parse-error': [Error];
  'no-route': [];
  end: [];
};
declare class Request extends EventEmitter<Events$1> {
  private _super;
  private _headers;
  private _cookies;
  private _url;
  private _method;
  private _query;
  private _body;
  res: Response | undefined;
  constructor(req: Request$1);
  url(part?: UrlPartName): string;
  private getMethod;
  method<T extends [] | [n: string]>(
    ...args: T
  ): T extends [] ? string : boolean;
  getRemoteIP(): string | undefined;
  headers<T extends [] | [n: string]>(
    ...args: T
  ): T extends [] ? Headers$1 : string | undefined;
  cookies(n?: string): string | Record<string, string>;
  query<T extends [] | [n: string]>(
    ...args: T
  ): T extends [] ? Record<string, string> : string | undefined;
  body<T extends [] | [n: string]>(
    ...args: T
  ): T extends [] ? Record<string, unknown> : unknown;
  _maybeParseBody(): Record<string, unknown>;
  _parseBody(): Record<string, unknown>;
}

type Events = {
  request: [Request, Response];
};
declare class App extends EventEmitter<Events> {
  private router;
  private routeRequest;
  route(pattern: string, handler: () => void): void;
  getRequestHandler(): (req: IncomingMessage, res: ServerResponse) => void;
}
declare function createApp(): App;

type Headers = Record<string, string | Array<string>>;
type Params = Record<string, string | Array<string>>;
type Options = {
  path: string;
  params?: Params;
  headers?: Headers;
  method?: string;
  body?: string | Buffer | Params;
  data?: string | Buffer | Params;
  protocol?: string;
  enc?: 'utf8';
};
type Result = {
  statusCode: number;
  headers: Headers;
  body: string | Buffer;
};
declare const request: (input: Options) => Result;

declare const http_d_request: typeof request;
declare namespace http_d {
  export { http_d_request as request };
}

export { createApp, http_d as http };