export declare const annotate: {
  <I, S>(tag: Context.Tag<I, S>, value: S): <A extends HttpApiEndpoint.All>(self: A) => A
  <A extends HttpApiEndpoint.All, I, S>(self: A, tag: Context.Tag<I, S>, value: S): A
}

export declare const annotateMerge: {
  <I>(context: Context.Context<I>): <A extends HttpApiEndpoint.All>(self: A) => A
  <A extends HttpApiEndpoint.All, I>(self: A, context: Context.Context<I>): A
}

export declare const del: <const Name extends string>(
  name: Name,
  path: HttpRouter.PathInput
) => HttpApiEndpoint<Name, "DELETE">

export declare const get: <const Name extends string>(
  name: Name,
  path: HttpRouter.PathInput
) => HttpApiEndpoint<Name, "GET">

export declare const make: <Method extends HttpMethod>(
  method: Method
) => <const Name extends string>(name: Name, path: HttpRouter.PathInput) => HttpApiEndpoint<Name, Method>

export declare const patch: <const Name extends string>(
  name: Name,
  path: HttpRouter.PathInput
) => HttpApiEndpoint<Name, "PATCH">

export declare const post: <const Name extends string>(
  name: Name,
  path: HttpRouter.PathInput
) => HttpApiEndpoint<Name, "POST">

export declare const put: <const Name extends string>(
  name: Name,
  path: HttpRouter.PathInput
) => HttpApiEndpoint<Name, "PUT">

export declare const isHttpApiEndpoint: (u: unknown) => u is HttpApiEndpoint<any, any, any>

export interface HttpApiEndpoint<
  out Name extends string,
  out Method extends HttpMethod,
  in out Path = never,
  in out Payload = never,
  in out Headers = never,
  in out Success = void,
  in out Error = never,
  out R = never
> extends Pipeable {
  readonly [TypeId]: TypeId
  readonly name: Name
  readonly path: HttpRouter.PathInput
  readonly method: Method
  readonly pathSchema: Option.Option<Schema.Schema<Path, unknown, R>>
  readonly payloadSchema: Option.Option<Schema.Schema<Payload, unknown, R>>
  readonly headersSchema: Option.Option<Schema.Schema<Headers, unknown, R>>
  readonly successSchema: Schema.Schema<Success, unknown, R>
  readonly errorSchema: Schema.Schema<Error, unknown, R>
  readonly annotations: Context.Context<never>
}

export interface All extends Pipeable {
  readonly [TypeId]: TypeId
  readonly name: string
  readonly path: HttpRouter.PathInput
  readonly method: HttpMethod
  readonly pathSchema: Option.Option<Schema.Schema.All>
  readonly payloadSchema: Option.Option<Schema.Schema.All>
  readonly headersSchema: Option.Option<Schema.Schema.All>
  readonly successSchema: Schema.Schema.Any
  readonly errorSchema: Schema.Schema.All
  readonly annotations: Context.Context<never>
}

export interface Any extends Pipeable {
  readonly [TypeId]: TypeId
  readonly name: string
  readonly path: HttpRouter.PathInput
  readonly method: HttpMethod
  readonly pathSchema: Option.Option<Schema.Schema.Any>
  readonly payloadSchema: Option.Option<Schema.Schema.Any>
  readonly headersSchema: Option.Option<Schema.Schema.Any>
  readonly successSchema: Schema.Schema.Any
  readonly errorSchema: Schema.Schema.Any
  readonly annotations: Context.Context<never>
}

export type ClientRequest<Path, Payload, Headers> = ([Path] extends [void] ? {} : { readonly path: Path }) &
  ([Headers] extends [never] ? {} : { readonly headers: Headers }) &
  ([Payload] extends [never]
    ? {}
    : [Payload] extends [Brand<HttpApiSchema.MultipartTypeId>]
      ? { readonly payload: FormData }
      : { readonly payload: Payload }) extends infer Req
  ? keyof Req extends never
    ? void
    : Req
  : void

export type Context<Endpoint> =
  Endpoint extends HttpApiEndpoint<
    infer _Name,
    infer _Method,
    infer _Path,
    infer _Payload,
    infer _Headers,
    infer _Success,
    infer _Error,
    infer _R
  >
    ? _R
    : never

export type Error<Endpoint extends All> =
  Endpoint extends HttpApiEndpoint<
    infer _Name,
    infer _Method,
    infer _Path,
    infer _Payload,
    infer _Headers,
    infer _Success,
    infer _Error,
    infer _R
  >
    ? _Error
    : never

export type ErrorWithName<Endpoints extends All, Name extends string> = Error<WithName<Endpoints, Name>>

export type ExcludeName<Endpoints extends All, Name extends string> = Exclude<Endpoints, { readonly name: Name }>

export type ExcludeProvided<R> = Exclude<R, HttpRouter.HttpRouter.DefaultServices | HttpRouter.HttpRouter.Provided>

export type Handler<Endpoint extends All, E, R> = (
  request: Types.Simplify<Request<Endpoint>>
) => Effect<Success<Endpoint>, E, R>

export type HandlerRedacted<Endpoint extends All, E, R> = (
  request: Types.Simplify<Request<Endpoint>>
) => Effect<readonly [Success<Endpoint>, Redacted], E, R>

export type HandlerRedactedWithName<Endpoints extends All, Name extends string, E, R> = HandlerRedacted<
  WithName<Endpoints, Name>,
  E,
  R
>

export type HandlerResponse<Endpoint extends All, E, R> = (
  request: Types.Simplify<Request<Endpoint>>
) => Effect<HttpServerResponse, E, R>

export type HandlerResponseWithName<Endpoints extends All, Name extends string, E, R> = HandlerResponse<
  WithName<Endpoints, Name>,
  E,
  R
>

export type HandlerWithName<Endpoints extends All, Name extends string, E, R> = Handler<WithName<Endpoints, Name>, E, R>

export type Headers<Endpoint extends All> =
  Endpoint extends HttpApiEndpoint<
    infer _Name,
    infer _Method,
    infer _Path,
    infer _Payload,
    infer _Headers,
    infer _Success,
    infer _Error,
    infer _R
  >
    ? _Headers
    : never

export type PathParsed<Endpoint extends All> =
  Endpoint extends HttpApiEndpoint<
    infer _Name,
    infer _Method,
    infer _Path,
    infer _Payload,
    infer _Headers,
    infer _Success,
    infer _Error,
    infer _R
  >
    ? _Path
    : never

export type Payload<Endpoint extends All> =
  Endpoint extends HttpApiEndpoint<
    infer _Name,
    infer _Method,
    infer _Path,
    infer _Payload,
    infer _Headers,
    infer _Success,
    infer _Error,
    infer _R
  >
    ? _Payload
    : never

export type Request<Endpoint extends All> = {
  readonly path: PathParsed<Endpoint>
} & ([Payload<Endpoint>] extends [infer P] ? ([P] extends [never] ? {} : { readonly payload: P }) : {}) &
  ([Headers<Endpoint>] extends [infer H] ? ([H] extends [never] ? {} : { readonly headers: H }) : {})

export type Success<Endpoint extends All> =
  Endpoint extends HttpApiEndpoint<
    infer _Name,
    infer _Method,
    infer _Path,
    infer _Payload,
    infer _Headers,
    infer _Success,
    infer _Error,
    infer _R
  >
    ? _Success
    : never

export type SuccessWithName<Endpoints extends All, Name extends string> = Success<WithName<Endpoints, Name>>

export type ValidateHeaders<S extends Schema.Schema.Any> =
  S extends Schema.Schema<infer _A, infer _I, infer _R>
    ? [_I] extends [Readonly<Record<string, string | undefined>>]
      ? {}
      : `Headers schema must be encodeable to strings`
    : {}

export type ValidatePath<S extends Schema.Schema.Any> =
  S extends Schema.Schema<infer _A, infer _I, infer _R>
    ? [_I] extends [Readonly<Record<string, string | undefined>>]
      ? {}
      : `Path schema must be encodeable to strings`
    : {}

export type ValidatePayload<Method extends HttpMethod, P extends Schema.Schema.All> = Method extends HttpMethod.NoBody
  ? P extends Schema.Schema<infer _A, infer _I, infer _R>
    ? [_I] extends [Readonly<Record<string, string | ReadonlyArray<string> | undefined>>]
      ? {}
      : `'${Method}' payload must be encodeable to strings`
    : {}
  : {}

export type WithName<Endpoints extends All, Name extends string> = Endpoints extends infer Endpoint
  ? Endpoint extends { readonly name: Name }
    ? Endpoint
    : never
  : never

export declare const schemaSuccess: <A extends HttpApiEndpoint.All>(
  self: A
) => Option.Option<Schema.Schema<HttpApiEndpoint.Success<A>, unknown, HttpApiEndpoint.Context<A>>>

export declare const prefix: {
  (prefix: HttpRouter.PathInput): <A extends HttpApiEndpoint.All>(self: A) => A
  <A extends HttpApiEndpoint.All>(self: A, prefix: HttpRouter.PathInput): A
}

export declare const setHeaders: {
  <Method extends HttpMethod, H extends Schema.Schema.Any>(
    schema: H & HttpApiEndpoint.ValidateHeaders<H>
  ): <Name extends string, _Path, _P, _H, _S, _E, _R>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>
  ) => HttpApiEndpoint<Name, Method, _Path, _P, Schema.Schema.Type<H>, _S, _E, _R | Schema.Schema.Context<H>>
  <Name extends string, Method extends HttpMethod, _Path, _P, _H, _S, _E, _R, H extends Schema.Schema.Any>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>,
    schema: H & HttpApiEndpoint.ValidateHeaders<H>
  ): HttpApiEndpoint<Name, Method, _Path, _P, Schema.Schema.Type<H>, _S, _E, _R | Schema.Schema.Context<H>>
}

export declare const setPath: {
  <Path extends Schema.Schema.Any>(
    schema: Path & HttpApiEndpoint.ValidatePath<Path>
  ): <Name extends string, Method extends HttpMethod, _Path, _P, _H, _S, _E, _R>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>
  ) => HttpApiEndpoint<Name, Method, Schema.Schema.Type<Path>, _P, _H, _S, _E, _R | Schema.Schema.Context<Path>>
  <Name extends string, Method extends HttpMethod, _Path, _P, _H, _S, _E, _R, Path extends Schema.Schema.Any>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>,
    schema: Path & HttpApiEndpoint.ValidatePath<Path>
  ): HttpApiEndpoint<Name, Method, Schema.Schema.Type<Path>, _P, _H, _S, _E, _R | Schema.Schema.Context<Path>>
}

export declare const setPayload: {
  <Method extends HttpMethod, P extends Schema.Schema.All>(
    schema: P & HttpApiEndpoint.ValidatePayload<Method, P>
  ): <Name extends string, _Path, _P, _H, _S, _E, _R>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>
  ) => HttpApiEndpoint<Name, Method, _Path, Schema.Schema.Type<P>, _H, _S, _E, _R | Schema.Schema.Context<P>>
  <Name extends string, Method extends HttpMethod, _Path, _P, _H, _S, _E, _R, P extends Schema.Schema.All>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>,
    schema: P & HttpApiEndpoint.ValidatePayload<Method, P>
  ): HttpApiEndpoint<Name, Method, _Path, Schema.Schema.Type<P>, _H, _S, _E, _R | Schema.Schema.Context<P>>
}

export declare const addError: {
  <E extends Schema.Schema.All>(
    schema: E,
    annotations?: { readonly status?: number | undefined }
  ): <Name extends string, Method extends HttpMethod, _Path, _P, _H, _S, _E, _R>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>
  ) => HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E | Schema.Schema.Type<E>, _R | Schema.Schema.Context<E>>
  <Name extends string, Method extends HttpMethod, _Path, _P, _H, _S, _E, _R, E extends Schema.Schema.All>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>,
    schema: E,
    annotations?: { readonly status?: number | undefined }
  ): HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E | Schema.Schema.Type<E>, _R | Schema.Schema.Context<E>>
}

export declare const setSuccess: {
  <S extends Schema.Schema.Any>(
    schema: S,
    annotations?: { readonly status?: number | undefined }
  ): <Name extends string, Method extends HttpMethod, _Path, _P, _H, _S, _E, _R>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>
  ) => HttpApiEndpoint<Name, Method, _Path, _P, _H, Schema.Schema.Type<S>, _E, _R | Schema.Schema.Context<S>>
  <Name extends string, Method extends HttpMethod, _Path, _P, _H, _S, _E, _R, S extends Schema.Schema.Any>(
    self: HttpApiEndpoint<Name, Method, _Path, _P, _H, _S, _E, _R>,
    schema: S,
    annotations?: { readonly status?: number | undefined }
  ): HttpApiEndpoint<Name, Method, _Path, _P, _H, Schema.Schema.Type<S>, _E, _R | Schema.Schema.Context<S>>
}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId