/// <reference types="bun-types" />
var Request$1 = Request;

var Response$1 = Response;

var ResponseInit$1 = ResponseInit;

var Headers$1 = Headers;

declare type StaticFileOptions = {
  /** Max age (in seconds) for the Cache-Control header */
  maxAge?: number | undefined;
  /** Include ETag and Last-Modified headers automatically (default: true) */
  cachingHeaders?: boolean | undefined;
};
declare type StaticFileInit = ResponseInit$1 & StaticFileOptions;
declare class StaticFile {
  readonly filePath: string;
  readonly responseInit: ResponseInit$1;
  readonly options: StaticFileOptions;
  constructor(filePath: string, init?: StaticFileInit);
}

declare type BodyStream = Request$1 extends {
  body: infer T;
}
  ? Exclude<T, null>
  : never;
declare type BodyAccessorArgs<M> = M extends MethodNoBody
  ? [ERROR: 'NO_BODY_ALLOWED_FOR_METHOD']
  : [];
declare class CustomRequest<M extends string, Params extends string> {
  request: Request$1;
  readonly method: M;
  readonly url: string;
  readonly headers: Headers$1;
  readonly path: string;
  readonly search: string;
  readonly query: URLSearchParams;
  readonly params: {
    [K in Params]: string;
  };
  _fallbackBody: BodyStream | undefined;
  constructor(request: Request$1);
  get body(): M extends MethodNoBody ? null : BodyStream;
  get bodyUsed(): boolean;
  arrayBuffer(..._: BodyAccessorArgs<M>): Promise<ArrayBuffer>;
  text(..._: BodyAccessorArgs<M>): Promise<string>;
  json<T = JSONValue>(..._: BodyAccessorArgs<M>): Promise<T>;
}

declare type MaybePromise<T> = T | Promise<T>;
declare type MaybeIntersect<T, U> = U extends undefined ? T : T & U;
declare type JsonPayload = Record<string, unknown> | Array<unknown>;
declare type ExtractParams<T extends string> = string extends T
  ? never
  : T extends `${infer _Start}:${infer Param}/${infer Rest}`
  ? Param | ExtractParams<Rest>
  : T extends `${infer _Start}:${infer Param}`
  ? Param
  : never;
declare type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS';
declare type MethodNoBody = Exclude<Method, 'POST' | 'PUT'>;
declare type Handler<M extends string, P extends string, RequestContext> = (
  request: MaybeIntersect<CustomRequest<M, ExtractParams<P>>, RequestContext>,
) => MaybePromise<
  Response$1 | StaticFile | JsonPayload | null | undefined | void
>;
declare type Route<RequestContext> = [
  string,
  string,
  Handler<string, string, RequestContext>,
];

declare type JSONValue =
  | null
  | boolean
  | number
  | string
  | Array<JSONValue>
  | {
      [key: string]: JSONValue;
    };

declare type HttpErrorInit = {
  status: number;
  message?: string;
};
declare class HttpError extends Error {
  readonly status: number;
  constructor(status: number, message?: string, options?: ErrorOptions);
  constructor(init: HttpErrorInit, options?: ErrorOptions);
  get name(): string;
  get [Symbol.toStringTag](): string;
}

declare class CustomResponse extends Response$1 {
  static file(filePath: string, init?: StaticFileInit): StaticFile;
}

declare const createApplication: <
  CtxGetter extends (request: Request) => object | undefined = (
    request: Request,
  ) => undefined,
>(applicationOptions?: {
  bodyParserMaxBufferSize?: number;
  errorHandler?: (error: Error) => MaybePromise<Response>;
  root?: string;
  allowStaticFrom?: string[];
  serveFile?: (params: {
    filePath: string;
    fullFilePath: string;
    status: number;
    statusText: string;
    headers: Headers;
    options: StaticFileOptions;
  }) => Promise<Response | null>;
  getContext?: CtxGetter;
}) => {
  defineRoutes: (
    fn: (app: {
      get: <P extends string>(
        path: P,
        handler: Handler<'GET', P, ReturnType<CtxGetter>>,
      ) => Route<ReturnType<CtxGetter>>;
      post: <P_1 extends string>(
        path: P_1,
        handler: Handler<'POST', P_1, ReturnType<CtxGetter>>,
      ) => Route<ReturnType<CtxGetter>>;
      put: <P_2 extends string>(
        path: P_2,
        handler: Handler<'PUT', P_2, ReturnType<CtxGetter>>,
      ) => Route<ReturnType<CtxGetter>>;
      delete: <P_3 extends string>(
        path: P_3,
        handler: Handler<'DELETE', P_3, ReturnType<CtxGetter>>,
      ) => Route<ReturnType<CtxGetter>>;
      route: <
        M extends
          | (string & {})
          | ('GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS' | '*'),
        P_4 extends string,
      >(
        method: M,
        path: P_4,
        handler: Handler<Uppercase<M>, P_4, ReturnType<CtxGetter>>,
      ) => Route<ReturnType<CtxGetter>>;
    }) => Route<ReturnType<CtxGetter>>[],
  ) => Route<ReturnType<CtxGetter>>[];
  createRequestHandler: (
    ...routeLists: Route<ReturnType<CtxGetter>>[][]
  ) => (request: Request) => Promise<Response>;
  attachRoutes: (
    ...routeLists: Route<ReturnType<CtxGetter>>[][]
  ) => (request: Request) => Promise<Response>;
};

export {
  HttpError,
  Request$1 as Request,
  CustomResponse as Response,
  createApplication,
};