HttpRouter

declare const append: {
  <R1, E1>(
    route: Route<E1, R1>,
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    route: Route<E1, R1>,
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const catchAll: {
  <E, E2, R2>(
    f: (e: E) => Handler<E2, R2>,
  ): <R>(self: HttpRouter<E, R>) => HttpRouter<E2, R | Exclude<R2, Provided>>;
  <E, R, E2, R2>(
    self: HttpRouter<E, R>,
    f: (e: E) => Handler<E2, R2>,
  ): HttpRouter<E2, R | Exclude<R2, Provided>>;
};

declare const catchAllCause: {
  <E, E2, R2>(
    f: (e: Cause<E>) => Handler<E2, R2>,
  ): <R>(self: HttpRouter<E, R>) => HttpRouter<E2, R | Exclude<R2, Provided>>;
  <E, R, E2, R2>(
    self: HttpRouter<E, R>,
    f: (e: Cause<E>) => Handler<E2, R2>,
  ): HttpRouter<E2, R | Exclude<R2, Provided>>;
};

declare const catchTag: {
  <K extends string, E, E1, R1>(
    k: K,
    f: (
      e: Extract<
        E,
        {
          _tag: K;
        }
      >,
    ) => Handler<E1, R1>,
  ): <R>(self: HttpRouter<E, R>) => HttpRouter<
    | E1
    | Exclude<
        E,
        {
          _tag: K;
        }
      >,
    R | Exclude<R1, Provided>
  >;
  <E, R, K extends string, E1, R1>(
    self: HttpRouter<E, R>,
    k: K,
    f: (
      e: Extract<
        E,
        {
          _tag: K;
        }
      >,
    ) => Handler<E1, R1>,
  ): HttpRouter<
    | E1
    | Exclude<
        E,
        {
          _tag: K;
        }
      >,
    R | Exclude<R1, Provided>
  >;
};

declare const catchTags: {
  <
    E,
    Cases extends
      | {}
      | {
          [K in string]: (
            error: Extract<
              E,
              {
                _tag: K;
              }
            >,
          ) => Handler<any, any>;
        },
  >(
    cases: Cases,
  ): <R>(self: HttpRouter<E, R>) => HttpRouter<
    | Exclude<
        E,
        {
          _tag: keyof Cases;
        }
      >
    | {
        [K in string | number | symbol]: Cases[K] extends (
          ...args: Array<any>
        ) => Effect<any, E, any>
          ? E
          : never;
      }[keyof Cases],
    | R
    | Exclude<
        {
          [K in string | number | symbol]: Cases[K] extends (
            ...args: Array<any>
          ) => Effect<any, any, R>
            ? R
            : never;
        }[keyof Cases],
        Provided
      >
  >;
  <
    R,
    E,
    Cases extends
      | {}
      | {
          [K in string]: (
            error: Extract<
              E,
              {
                _tag: K;
              }
            >,
          ) => Handler<any, any>;
        },
  >(
    self: HttpRouter<E, R>,
    cases: Cases,
  ): HttpRouter<
    | Exclude<
        E,
        {
          _tag: keyof Cases;
        }
      >
    | {
        [K in string | number | symbol]: Cases[K] extends (
          ...args: Array<any>
        ) => Effect<any, E, any>
          ? E
          : never;
      }[keyof Cases],
    | R
    | Exclude<
        {
          [K in string | number | symbol]: Cases[K] extends (
            ...args: Array<any>
          ) => Effect<any, any, R>
            ? R
            : never;
        }[keyof Cases],
        Provided
      >
  >;
};

declare const concat: {
  <R1, E1>(that: HttpRouter<E1, R1>): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R1 | R>;
  <E, R, R1, E1>(self: HttpRouter<E, R>, that: HttpRouter<E1, R1>): HttpRouter<E | E1, R | R1>;
};

declare const concatAll: <Routers extends ReadonlyArray<HttpRouter<unknown, unknown>>>(
  ...routers: Routers
) => [Routers[number]] extends [HttpRouter<infer E, infer R>] ? HttpRouter<E, R> : never;

declare const prefixAll: {
  (prefix: PathInput): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E, R>;
  <E, R>(self: HttpRouter<E, R>, prefix: PathInput): HttpRouter<E, R>;
};

declare const provideService: {
  <T extends Tag<any, any>>(
    tag: T,
    service: Service<T>,
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E, Exclude<R, Identifier<T>>>;
  <E, R, T extends Tag<any, any>>(
    self: HttpRouter<E, R>,
    tag: T,
    service: Service<T>,
  ): HttpRouter<E, Exclude<R, Identifier<T>>>;
};

declare const provideServiceEffect: {
  <T extends Tag<any, any>, R1, E1>(
    tag: T,
    effect: Effect<Service<T>, E1, R1>,
  ): <E, R>(
    self: HttpRouter<E, R>,
  ) => HttpRouter<
    E1 | E,
    Exclude<R, Identifier<T>> | Exclude<Exclude<R1, Provided>, Identifier<T>>
  >;
  <E, R, T extends Tag<any, any>, R1, E1>(
    self: HttpRouter<E, R>,
    tag: T,
    effect: Effect<Service<T>, E1, R1>,
  ): HttpRouter<E | E1, Exclude<R, Identifier<T>> | Exclude<Exclude<R1, Provided>, Identifier<T>>>;
};

declare const transform: {
  <E, R, R1, E1>(
    f: (self: Handler<E, R>) => HttpApp<Respondable, E1, R1>,
  ): (self: HttpRouter<E, R>) => HttpRouter<E1, Exclude<R1, Provided>>;
  <E, R, R1, E1>(
    self: HttpRouter<E, R>,
    f: (self: Handler<E, R>) => HttpApp<Respondable, E1, R1>,
  ): HttpRouter<E1, Exclude<R1, Provided>>;
};

declare const use: {
  <E, R, R1, E1>(
    f: (self: Middleware<E, R>) => Default<E1, R1>,
  ): (self: HttpRouter<E, R>) => HttpRouter<E1, Exclude<R1, Provided>>;
  <E, R, R1, E1>(
    self: HttpRouter<E, R>,
    f: (self: Middleware<E, R>) => Default<E1, R1>,
  ): HttpRouter<E1, Exclude<R1, Provided>>;
};

declare const empty: HttpRouter;

declare const fromIterable: <R extends Route<any, any>>(
  routes: Iterable<R>,
) => HttpRouter<
  R extends Route<infer E, infer _> ? E : never,
  R extends Route<infer _, infer Env> ? Env : never
>;

declare const makeRoute: <E, R>(
  method: Method.HttpMethod | "*",
  path: PathInput,
  handler: Route.Handler<E, R>,
  options?: {
    readonly prefix?: string;
    readonly uninterruptible?: boolean;
  },
) => Route<E, HttpRouter.ExcludeProvided<R>>;

interface HttpRouter<E = never, R = never>
  extends Default<E | Error.RouteNotFound, Exclude<R, RouteContext>>, Inspectable {
  readonly [TypeId]: typeof TypeId;
  readonly mounts: Chunk<
    readonly [
      string,
      Default<E, R>,
      (
        | {
            readonly includePrefix?: boolean;
          }
        | undefined
      ),
    ]
  >;
  readonly routes: Chunk<Route<E, R>>;
}

type PathInput = `/${string}` | "*";

interface Route<E = never, R = never> extends Inspectable {
  readonly [RouteTypeId]: typeof RouteTypeId;
  readonly handler: Handler<E, R>;
  readonly method: HttpMethod | "*";
  readonly path: PathInput;
  readonly prefix: Option<string>;
  readonly uninterruptible: boolean;
}

interface RouteContext {
  readonly [RouteContextTypeId]: typeof RouteContextTypeId;
  readonly params: Readonly<Record<string, string | undefined>>;
  readonly route: Route<unknown, unknown>;
}

declare const params: Effect.Effect<
  Readonly<Record<string, string | undefined>>,
  never,
  RouteContext
>;

declare const RouteContext: Tag<RouteContext, RouteContext>;

declare const schemaJson: <
  R,
  I extends Partial<{
    readonly body: any;
    readonly cookies: Readonly<Record<string, string | undefined>>;
    readonly headers: Readonly<Record<string, string | undefined>>;
    readonly method: Method.HttpMethod;
    readonly pathParams: Readonly<Record<string, string | undefined>>;
    readonly searchParams: Readonly<Record<string, string | ReadonlyArray<string> | undefined>>;
    readonly url: string;
  }>,
  A,
>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions,
) => Effect.Effect<
  A,
  Error.RequestError | ParseResult.ParseError,
  RouteContext | R | ServerRequest.HttpServerRequest | ServerRequest.ParsedSearchParams
>;

declare const schemaNoBody: <
  R,
  I extends Partial<{
    readonly cookies: Readonly<Record<string, string | undefined>>;
    readonly headers: Readonly<Record<string, string | undefined>>;
    readonly method: Method.HttpMethod;
    readonly pathParams: Readonly<Record<string, string | undefined>>;
    readonly searchParams: Readonly<Record<string, string | ReadonlyArray<string> | undefined>>;
    readonly url: string;
  }>,
  A,
>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions,
) => Effect.Effect<
  A,
  ParseResult.ParseError,
  R | RouteContext | ServerRequest.HttpServerRequest | ServerRequest.ParsedSearchParams
>;

declare const schemaParams: <
  A,
  I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>,
  R,
>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions,
) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext | ServerRequest.ParsedSearchParams>;

declare const schemaPathParams: <A, I extends Readonly<Record<string, string | undefined>>, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions,
) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext>;

declare const currentRouterConfig: FiberRef<Partial<RouterConfig>>;

declare const setRouterConfig: (config: Partial<RouterConfig>) => Layer.Layer<never>;

declare const withRouterConfig: {
  (config: RouterConfig): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
  <A, E, R>(effect: Effect<A, E, R>, config: RouterConfig): Effect<A, E, R>;
};

declare const all: {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const del: {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const get: {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const head: {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const mount: {
  <R1, E1>(
    path: `/${string}`,
    that: HttpRouter<E1, R1>,
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R1 | R>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: `/${string}`,
    that: HttpRouter<E1, R1>,
  ): HttpRouter<E | E1, R | R1>;
};

declare const mountApp: {
  <R1, E1>(
    path: `/${string}`,
    that: Default<E1, R1>,
    options?: {
      readonly includePrefix?: boolean;
    },
  ): <E, R>(
    self: HttpRouter<E, R>,
  ) => HttpRouter<E1 | E, Exclude<R1, Provided> | Exclude<R, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: `/${string}`,
    that: Default<E1, R1>,
    options?: {
      readonly includePrefix?: boolean;
    },
  ): HttpRouter<E | E1, Exclude<R, Provided> | Exclude<R1, Provided>>;
};

declare const options: {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const patch: {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const post: {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const put: {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(self: HttpRouter<E, R>) => HttpRouter<E1 | E, R | Exclude<R1, Provided>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Provided>>;
};

declare const route: (method: Method.HttpMethod | "*") => {
  <R1, E1>(
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): <E, R>(
    self: HttpRouter<E, R>,
  ) => HttpRouter<E1 | E, R | Exclude<R1, Scope | HttpServerRequest | RouteContext>>;
  <E, R, E1, R1>(
    self: HttpRouter<E, R>,
    path: PathInput,
    handler: Handler<E1, R1>,
    options?: {
      readonly uninterruptible?: boolean;
    },
  ): HttpRouter<E | E1, R | Exclude<R1, Scope | HttpServerRequest | RouteContext>>;
};

declare class Default extends any {
  constructor(_: never);
}

declare const Tag: <Name extends string>(
  id: Name,
) => <Self, R = never, E = unknown>() => HttpRouter.TagClass<
  Self,
  Name,
  E,
  R | HttpRouter.DefaultServices
>;

declare const RouteContextTypeId: unique symbol;

type RouteContextTypeId = typeof RouteContextTypeId;

declare const RouteTypeId: unique symbol;

type RouteTypeId = typeof RouteTypeId;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;

declare const prefixPath: {
  (prefix: string): (self: string) => string;
  (self: string, prefix: string): string;
};

declare const toHttpApp: <E, R>(
  self: HttpRouter<E, R>,
) => Effect.Effect<App.Default<E | Error.RouteNotFound, R>>;