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