HttpServerRequest

declare const persistedMultipart: Effect.Effect<
  unknown,
  Multipart.MultipartError,
  Scope.Scope | FileSystem.FileSystem | Path.Path | HttpServerRequest
>;

declare const upgrade: Effect.Effect<Socket.Socket, Error.RequestError, HttpServerRequest>;

declare const upgradeChannel: <IE = never>() => Channel<
  Chunk<Uint8Array>,
  Chunk<Uint8Array | string | Socket.CloseEvent>,
  Error.RequestError | IE | Socket.SocketError,
  IE,
  void,
  unknown,
  HttpServerRequest
>;

declare const HttpServerRequest: Tag<HttpServerRequest, HttpServerRequest>;

declare const fromWeb: (request: Request) => HttpServerRequest;

declare const toURL: (self: HttpServerRequest) => Option.Option<URL>;

declare function toWeb(
  self: HttpServerRequest,
  options?: {
    readonly signal?: AbortSignal;
  },
): Effect<Request, RequestError>;

declare function toWebEither(
  self: HttpServerRequest,
  options?: {
    readonly runtime?: any;
    readonly signal?: AbortSignal;
  },
): Either<Request, RequestError>;

declare class MaxBodySize extends any {
  constructor();
}

declare const withMaxBodySize: (size: Option<SizeInput>) => <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R> & <A, E, R>(effect: Effect<A, E, R>, size: Option<SizeInput>) => Effect<A, E, R>

interface HttpServerRequest extends HttpIncomingMessage<Error.RequestError> {
  readonly [TypeId]: typeof TypeId;
  readonly cookies: ReadonlyRecord<string, string>;
  readonly method: HttpMethod;
  readonly modify: (options: {
    readonly headers?: Headers;
    readonly remoteAddress?: string;
    readonly url?: string;
  }) => HttpServerRequest;
  readonly multipart: Effect<Persisted, MultipartError, Scope | FileSystem | Path>;
  readonly multipartStream: Stream<Part, MultipartError>;
  readonly originalUrl: string;
  readonly source: unknown;
  readonly upgrade: Effect<Socket, RequestError>;
  readonly url: string;
}

declare const schemaBodyForm: <A, I extends Partial<Multipart.Persisted>, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions,
) => Effect.Effect<
  A,
  Multipart.MultipartError | ParseResult.ParseError | Error.RequestError,
  R | HttpServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path
>;

declare const schemaBodyFormJson: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions,
) => (
  field: string,
) => Effect.Effect<
  A,
  ParseResult.ParseError | Error.RequestError,
  R | HttpServerRequest | FileSystem.FileSystem | Path.Path | Scope.Scope
>;

declare const schemaBodyJson: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions,
) => Effect.Effect<A, Error.RequestError | ParseResult.ParseError, HttpServerRequest | R>;

declare const schemaBodyMultipart: <A, I extends Partial<Multipart.Persisted>, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions,
) => Effect.Effect<
  A,
  Multipart.MultipartError | ParseResult.ParseError,
  R | HttpServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path
>;

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

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

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

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

declare const ParsedSearchParams: Tag<
  ParsedSearchParams,
  ReadonlyRecord<string, string | Array<string>>
>;

interface ParsedSearchParams {
  readonly _: typeof _;
}

declare const searchParamsFromURL: (url: URL) => ReadonlyRecord<string, string | Array<string>>;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;