export declare const persistedMultipart: Effect.Effect<unknown, Multipart.MultipartError, any>

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

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

export declare const HttpServerRequest: Context.Tag<HttpServerRequest, HttpServerRequest>

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

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

export declare const maxBodySize: FiberRef.FiberRef<Option.Option<Brand.Branded<bigint, "Size">>>

export interface HttpServerRequest extends IncomingMessage.HttpIncomingMessage<Error.RequestError> {
  readonly [TypeId]: TypeId
  readonly source: unknown
  readonly url: string
  readonly originalUrl: string
  readonly method: HttpMethod
  readonly cookies: ReadonlyRecord<string, string>

  readonly multipart: Effect.Effect<
    Multipart.Persisted,
    Multipart.MultipartError,
    Scope.Scope | FileSystem.FileSystem | Path.Path
  >
  readonly multipartStream: Stream.Stream<Multipart.Part, Multipart.MultipartError>

  readonly upgrade: Effect.Effect<Socket.Socket, Error.RequestError>

  readonly modify: (options: {
    readonly url?: string
    readonly headers?: Headers.Headers
    readonly remoteAddress?: string
  }) => HttpServerRequest
}

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

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

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

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

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

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

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

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

export declare const ParsedSearchParams: Context.Tag<ParsedSearchParams, ReadonlyRecord<string, string | string[]>>

export interface ParsedSearchParams {
  readonly _: unique symbol
}

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

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId