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

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

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

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

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

export declare const maxBodySize: FiberRef.FiberRef<Option.Option<Brand.Branded<bigint, "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 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
  }) => ServerRequest
}

export declare const schemaBodyForm: <R, I extends Partial<Multipart.Persisted>, A>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => Effect.Effect<A, any, any>

export declare const schemaBodyFormJson: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => (field: string) => Effect.Effect<A, any, any>

export declare const schemaBodyJson: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => Effect.Effect<A, any, ServerRequest | R>

export declare const schemaBodyMultipart: <R, I extends Partial<Multipart.Persisted>, A>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => Effect.Effect<A, any, any>

export declare const schemaBodyUrlParams: <R, I extends Readonly<Record<string, string>>, A>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => Effect.Effect<A, any, ServerRequest | R>

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

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

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId