export declare const removeCookie: {
  (name: string): (self: HttpServerResponse) => HttpServerResponse
  (self: HttpServerResponse, name: string): HttpServerResponse
}

export declare const replaceCookies: {
  (cookies: Cookies): (self: HttpServerResponse) => HttpServerResponse
  (self: HttpServerResponse, cookies: Cookies): HttpServerResponse
}

export declare const setBody: {
  (body: Body.HttpBody): (self: HttpServerResponse) => HttpServerResponse
  (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse
}

export declare const setCookie: {
  (
    name: string,
    value: string,
    options?: Cookie["options"]
  ): (self: HttpServerResponse) => Effect.Effect<HttpServerResponse, CookiesError>
  (
    self: HttpServerResponse,
    name: string,
    value: string,
    options?: Cookie["options"]
  ): Effect.Effect<HttpServerResponse, CookiesError>
}

export declare const setCookies: {
  (
    cookies: Iterable<readonly [name: string, value: string, options?: Cookie["options"]]>
  ): (self: HttpServerResponse) => Effect.Effect<HttpServerResponse, CookiesError, never>
  (
    self: HttpServerResponse,
    cookies: Iterable<readonly [name: string, value: string, options?: Cookie["options"]]>
  ): Effect.Effect<HttpServerResponse, CookiesError, never>
}

export declare const setHeader: {
  (key: string, value: string): (self: HttpServerResponse) => HttpServerResponse
  (self: HttpServerResponse, key: string, value: string): HttpServerResponse
}

export declare const setHeaders: {
  (input: Headers.Input): (self: HttpServerResponse) => HttpServerResponse
  (self: HttpServerResponse, input: Headers.Input): HttpServerResponse
}

export declare const setStatus: {
  (status: number, statusText?: string | undefined): (self: HttpServerResponse) => HttpServerResponse
  (self: HttpServerResponse, status: number, statusText?: string | undefined): HttpServerResponse
}

export declare const unsafeSetCookie: {
  (name: string, value: string, options?: Cookie["options"]): (self: HttpServerResponse) => HttpServerResponse
  (self: HttpServerResponse, name: string, value: string, options?: Cookie["options"]): HttpServerResponse
}

export declare const unsafeSetCookies: {
  (
    cookies: Iterable<readonly [name: string, value: string, options?: Cookie["options"]]>
  ): (self: HttpServerResponse) => HttpServerResponse
  (
    self: HttpServerResponse,
    cookies: Iterable<readonly [name: string, value: string, options?: Cookie["options"]]>
  ): HttpServerResponse
}

export declare const updateCookies: {
  (f: (cookies: Cookies) => Cookies): (self: HttpServerResponse) => HttpServerResponse
  (self: HttpServerResponse, f: (cookies: Cookies) => Cookies): HttpServerResponse
}

export declare const empty: (options?: Options.WithContent | undefined) => HttpServerResponse

export declare const file: (
  path: string,
  options?: (Options & FileSystem.StreamOptions) | undefined
) => Effect.Effect<HttpServerResponse, PlatformError.PlatformError, Platform.HttpPlatform>

export declare const fileWeb: (
  file: Body.HttpBody.FileLike,
  options?: (Options.WithContent & FileSystem.StreamOptions) | undefined
) => Effect.Effect<HttpServerResponse, never, Platform.HttpPlatform>

export declare const formData: (body: FormData, options?: Options.WithContent | undefined) => HttpServerResponse

export declare const html: {
  <A extends ReadonlyArray<Template.Interpolated>>(
    strings: TemplateStringsArray,
    ...args: A
  ): Effect.Effect<HttpServerResponse, Template.Interpolated.Error<A[number]>, Template.Interpolated.Context<A[number]>>
  (html: string): HttpServerResponse
}

export declare const htmlStream: <A extends ReadonlyArray<Template.InterpolatedWithStream>>(
  strings: TemplateStringsArray,
  ...args: A
) => Effect.Effect<HttpServerResponse, never, Template.Interpolated.Context<A[number]>>

export declare const json: (
  body: unknown,
  options?: Options.WithContentType | undefined
) => Effect.Effect<HttpServerResponse, Body.HttpBodyError>

export declare const raw: (body: unknown, options?: Options | undefined) => HttpServerResponse

export declare const schemaJson: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => (body: A, options?: Options.WithContent | undefined) => Effect.Effect<HttpServerResponse, Body.HttpBodyError, R>

export declare const stream: <E>(
  body: Stream.Stream<Uint8Array, E, never>,
  options?: Options | undefined
) => HttpServerResponse

export declare const text: (body: string, options?: Options.WithContentType | undefined) => HttpServerResponse

export declare const uint8Array: (body: Uint8Array, options?: Options.WithContentType | undefined) => HttpServerResponse

export declare const unsafeJson: (body: unknown, options?: Options.WithContentType | undefined) => HttpServerResponse

export declare const urlParams: (
  body: UrlParams.Input,
  options?: Options.WithContentType | undefined
) => HttpServerResponse

export declare const toWeb: (
  response: HttpServerResponse,
  options?: { readonly withoutBody?: boolean | undefined; readonly runtime?: Runtime.Runtime<never> | undefined }
) => Response

export interface HttpServerResponse extends Effect.Effect<HttpServerResponse>, Inspectable, Respondable {
  readonly [TypeId]: TypeId
  readonly status: number
  readonly statusText?: string | undefined
  readonly headers: Headers.Headers
  readonly cookies: Cookies
  readonly body: Body.HttpBody
}

export interface Options {
  readonly status?: number | undefined
  readonly statusText?: string | undefined
  readonly headers?: Headers.Headers | undefined
  readonly cookies?: Cookies | undefined
  readonly contentType?: string | undefined
  readonly contentLength?: number | undefined
}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

export interface WithContent extends Omit<Options, "contentType" | "contentLength"> {}

export interface WithContentType extends Omit<Options, "contentLength"> {}

export declare const isServerResponse: (u: unknown) => u is HttpServerResponse