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

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

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

export declare const maxBodySize: FiberRef<Option<FileSystem.Size>>

export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.RequestError> {
  readonly [TypeId]: TypeId
  readonly source: unknown
  readonly url: string
  readonly originalUrl: string
  readonly method: Method

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

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

export declare const schemaBodyForm: <I extends Multipart.Persisted, A>(
  schema: Schema.Schema<I, A>
) => Effect.Effect<
  Scope.Scope | Path.Path | FileSystem.FileSystem | ServerRequest,
  ParseResult.ParseError | Multipart.MultipartError | Error.RequestError,
  A
>

export declare const schemaBodyFormJson: <I, A>(
  schema: Schema.Schema<I, A>
) => (
  field: string
) => Effect.Effect<
  Scope.Scope | Path.Path | FileSystem.FileSystem | ServerRequest,
  ParseResult.ParseError | Error.RequestError,
  A
>

export declare const schemaBodyJson: <I, A>(
  schema: Schema.Schema<I, A>
) => Effect.Effect<ServerRequest, ParseResult.ParseError | Error.RequestError, A>

export declare const schemaBodyMultipart: <I extends Multipart.Persisted, A>(
  schema: Schema.Schema<I, A>
) => Effect.Effect<
  Scope.Scope | Path.Path | FileSystem.FileSystem | ServerRequest,
  ParseResult.ParseError | Multipart.MultipartError,
  A
>

export declare const schemaBodyUrlParams: <I extends Readonly<Record<string, string>>, A>(
  schema: Schema.Schema<I, A>
) => Effect.Effect<ServerRequest, ParseResult.ParseError | Error.RequestError, A>

export declare const schemaHeaders: <I extends Readonly<Record<string, string>>, A>(
  schema: Schema.Schema<I, A>
) => Effect.Effect<ServerRequest, ParseResult.ParseError, A>

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId