/// <reference types="node" />
import type { Byte } from '@principia/base/Byte';
import type { FIO, IO, UIO } from '@principia/base/IO';
import type { ReadonlyRecord } from '@principia/base/Record';
import type * as http from 'http';
import type { Readable } from 'stream';
import * as Ma from '@principia/base/Managed';
import * as M from '@principia/base/Maybe';
import * as NT from '@principia/base/Newtype';
import * as SRef from '@principia/base/SRef';
import * as S from '@principia/base/Stream';
import { HttpException } from './HttpException';
import * as Status from './StatusCode';
interface CloseEvent {
    readonly _tag: 'Close';
}
interface ErrorEvent {
    readonly _tag: 'Error';
    readonly error: Error;
}
interface DrainEvent {
    readonly _tag: 'Drain';
}
interface FinishEvent {
    readonly _tag: 'Finish';
}
interface PipeEvent {
    readonly _tag: 'Pipe';
    readonly src: Readable;
}
interface UnpipeEvent {
    readonly _tag: 'Unpipe';
    readonly src: Readable;
}
export declare type ResponseEvent = CloseEvent | DrainEvent | ErrorEvent | FinishEvent | PipeEvent | UnpipeEvent;
export interface HttpResponseCompleted extends NT.Newtype<'HttpResponseCompleted', void> {
}
export declare const HttpResponseCompleted: NT.NewtypeIso<HttpResponseCompleted>;
export declare class HttpResponse {
    readonly ref: SRef.USRef<http.ServerResponse>;
    eventStream: Ma.Managed<unknown, never, S.Stream<unknown, never, ResponseEvent>>;
    constructor(ref: SRef.USRef<http.ServerResponse>);
    access<R, E, A>(f: (res: http.ServerResponse) => IO<R, E, A>): IO<R, E, A>;
    modify<R, E>(f: (res: http.ServerResponse) => IO<R, E, http.ServerResponse>): IO<R, E, void>;
    status(s: Status.StatusCode): UIO<void>;
    get headers(): UIO<http.OutgoingHttpHeaders>;
    get(name: string): UIO<M.Maybe<http.OutgoingHttpHeader>>;
    set(headers: ReadonlyRecord<string, http.OutgoingHttpHeader>): FIO<HttpException, void>;
    has(name: string): UIO<boolean>;
    write(chunk: string | Buffer): FIO<HttpException, void>;
    pipeFrom<R, E>(stream: S.Stream<R, E, Byte>): IO<R, HttpException, void>;
    end(): UIO<HttpResponseCompleted>;
}
export {};
//# sourceMappingURL=HttpResponse.d.ts.map