HttpServerResponse

declare const expireCookie: {
  (
    name: string,
    options?: Omit<
      | {
          readonly domain?: string;
          readonly expires?: Date;
          readonly httpOnly?: boolean;
          readonly maxAge?: Duration.DurationInput;
          readonly partitioned?: boolean;
          readonly path?: string;
          readonly priority?: "low" | "medium" | "high";
          readonly sameSite?: "lax" | "strict" | "none";
          readonly secure?: boolean;
        }
      | undefined,
      "expires" | "maxAge"
    >,
  ): (self: HttpServerResponse) => HttpServerResponse;
  (
    self: HttpServerResponse,
    name: string,
    options?: Omit<
      | {
          readonly domain?: string;
          readonly expires?: Date;
          readonly httpOnly?: boolean;
          readonly maxAge?: Duration.DurationInput;
          readonly partitioned?: boolean;
          readonly path?: string;
          readonly priority?: "low" | "medium" | "high";
          readonly sameSite?: "lax" | "strict" | "none";
          readonly secure?: boolean;
        }
      | undefined,
      "expires" | "maxAge"
    >,
  ): HttpServerResponse;
};

declare const mergeCookies: {
  (cookies: Cookies): (self: HttpServerResponse) => HttpServerResponse;
  (self: HttpServerResponse, cookies: Cookies): HttpServerResponse;
};

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

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

declare const setBody: {
  (body: HttpBody): (self: HttpServerResponse) => HttpServerResponse;
  (self: HttpServerResponse, body: HttpBody): HttpServerResponse;
};

declare const setCookie: {
  (
    name: string,
    value: string,
    options?: {
      readonly domain?: string;
      readonly expires?: Date;
      readonly httpOnly?: boolean;
      readonly maxAge?: Duration.DurationInput;
      readonly partitioned?: boolean;
      readonly path?: string;
      readonly priority?: "low" | "medium" | "high";
      readonly sameSite?: "lax" | "strict" | "none";
      readonly secure?: boolean;
    },
  ): (self: HttpServerResponse) => Effect<HttpServerResponse, CookiesError>;
  (
    self: HttpServerResponse,
    name: string,
    value: string,
    options?: {
      readonly domain?: string;
      readonly expires?: Date;
      readonly httpOnly?: boolean;
      readonly maxAge?: Duration.DurationInput;
      readonly partitioned?: boolean;
      readonly path?: string;
      readonly priority?: "low" | "medium" | "high";
      readonly sameSite?: "lax" | "strict" | "none";
      readonly secure?: boolean;
    },
  ): Effect<HttpServerResponse, CookiesError>;
};

declare const setCookies: {
  (
    cookies: Iterable<
      readonly [
        string,
        string,
        (
          | {
              readonly domain?: string;
              readonly expires?: Date;
              readonly httpOnly?: boolean;
              readonly maxAge?: Duration.DurationInput;
              readonly partitioned?: boolean;
              readonly path?: string;
              readonly priority?: "low" | "medium" | "high";
              readonly sameSite?: "lax" | "strict" | "none";
              readonly secure?: boolean;
            }
          | undefined
        ),
      ]
    >,
  ): (self: HttpServerResponse) => Effect<HttpServerResponse, CookiesError, never>;
  (
    self: HttpServerResponse,
    cookies: Iterable<
      readonly [
        string,
        string,
        (
          | {
              readonly domain?: string;
              readonly expires?: Date;
              readonly httpOnly?: boolean;
              readonly maxAge?: Duration.DurationInput;
              readonly partitioned?: boolean;
              readonly path?: string;
              readonly priority?: "low" | "medium" | "high";
              readonly sameSite?: "lax" | "strict" | "none";
              readonly secure?: boolean;
            }
          | undefined
        ),
      ]
    >,
  ): Effect<HttpServerResponse, CookiesError, never>;
};

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

declare const setHeaders: {
  (input: Input): (self: HttpServerResponse) => HttpServerResponse;
  (self: HttpServerResponse, input: Input): HttpServerResponse;
};

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

declare const unsafeSetCookie: {
  (
    name: string,
    value: string,
    options?: {
      readonly domain?: string;
      readonly expires?: Date;
      readonly httpOnly?: boolean;
      readonly maxAge?: Duration.DurationInput;
      readonly partitioned?: boolean;
      readonly path?: string;
      readonly priority?: "low" | "medium" | "high";
      readonly sameSite?: "lax" | "strict" | "none";
      readonly secure?: boolean;
    },
  ): (self: HttpServerResponse) => HttpServerResponse;
  (
    self: HttpServerResponse,
    name: string,
    value: string,
    options?: {
      readonly domain?: string;
      readonly expires?: Date;
      readonly httpOnly?: boolean;
      readonly maxAge?: Duration.DurationInput;
      readonly partitioned?: boolean;
      readonly path?: string;
      readonly priority?: "low" | "medium" | "high";
      readonly sameSite?: "lax" | "strict" | "none";
      readonly secure?: boolean;
    },
  ): HttpServerResponse;
};

declare const unsafeSetCookies: {
  (
    cookies: Iterable<
      readonly [
        string,
        string,
        (
          | {
              readonly domain?: string;
              readonly expires?: Date;
              readonly httpOnly?: boolean;
              readonly maxAge?: Duration.DurationInput;
              readonly partitioned?: boolean;
              readonly path?: string;
              readonly priority?: "low" | "medium" | "high";
              readonly sameSite?: "lax" | "strict" | "none";
              readonly secure?: boolean;
            }
          | undefined
        ),
      ]
    >,
  ): (self: HttpServerResponse) => HttpServerResponse;
  (
    self: HttpServerResponse,
    cookies: Iterable<
      readonly [
        string,
        string,
        (
          | {
              readonly domain?: string;
              readonly expires?: Date;
              readonly httpOnly?: boolean;
              readonly maxAge?: Duration.DurationInput;
              readonly partitioned?: boolean;
              readonly path?: string;
              readonly priority?: "low" | "medium" | "high";
              readonly sameSite?: "lax" | "strict" | "none";
              readonly secure?: boolean;
            }
          | undefined
        ),
      ]
    >,
  ): HttpServerResponse;
};

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

declare const empty: (options?: Options.WithContent) => HttpServerResponse;

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

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

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

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

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

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

declare const raw: (body: unknown, options?: Options) => HttpServerResponse;

declare const redirect: (
  location: string | URL,
  options?: Options.WithContentType,
) => HttpServerResponse;

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

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

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

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

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

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

declare function fromWeb(response: Response): HttpServerResponse;

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

interface HttpServerResponse extends Effect<HttpServerResponse>, Inspectable, Respondable {
  readonly [TypeId]: typeof TypeId;
  readonly body: HttpBody;
  readonly cookies: Cookies;
  readonly headers: Headers;
  readonly status: number;
  readonly statusText?: string;
}

interface Options {
  readonly contentLength?: number;
  readonly contentType?: string;
  readonly cookies?: Cookies;
  readonly headers?: Input;
  readonly status?: number;
  readonly statusText?: string;
}

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

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;