declare const empty: Empty

declare const file: (
  path: string,
  options?: FileSystem.StreamOptions & { readonly contentType?: string }
) => Effect.Effect<Stream, PlatformError.PlatformError, FileSystem.FileSystem>

declare const fileInfo: (
  path: string,
  info: FileSystem.File.Info,
  options?: FileSystem.StreamOptions & { readonly contentType?: string }
) => Effect.Effect<Stream, PlatformError.PlatformError, FileSystem.FileSystem>

declare const fileWeb: (file: HttpBody.FileLike) => Stream

declare const formData: (body: globalThis.FormData) => FormData

declare const json: (body: unknown) => Effect.Effect<Uint8Array, HttpBodyError>

declare const jsonSchema: <A, I, R>(
  schema: Schema.Schema<A, I, R>
) => (body: A) => Effect.Effect<Uint8Array, HttpBodyError, R>

declare const raw: (
  body: unknown,
  options?: { readonly contentType?: string | undefined; readonly contentLength?: number | undefined } | undefined
) => Raw

declare const stream: (
  body: Stream_.Stream<globalThis.Uint8Array, unknown>,
  contentType?: string,
  contentLength?: number,
  etag?: string
) => Stream

declare const text: (body: string, contentType?: string) => Uint8Array

declare const uint8Array: (body: globalThis.Uint8Array, contentType?: string) => Uint8Array

declare const unsafeJson: (body: unknown) => Uint8Array

declare const urlParams: (urlParams: UrlParams.UrlParams) => Uint8Array

type ErrorReason =
  | {
      readonly _tag: "JsonError"
      readonly error: unknown
    }
  | {
      readonly _tag: "SchemaError"
      readonly error: ParseResult.ParseError
    }

declare const HttpBodyError: (reason: ErrorReason) => HttpBodyError

export interface HttpBodyError {
  readonly [ErrorTypeId]: ErrorTypeId
  readonly _tag: "HttpBodyError"
  readonly reason: ErrorReason
}

export interface Empty extends HttpBody.Proto {
  readonly _tag: "Empty"
}

export interface FormData extends HttpBody.Proto {
  readonly _tag: "FormData"
  readonly formData: globalThis.FormData
}

type HttpBody = Empty | Raw | Uint8Array | FormData | Stream

export interface Raw extends HttpBody.Proto {
  readonly _tag: "Raw"
  readonly body: unknown
}

export interface Stream extends HttpBody.Proto {
  readonly _tag: "Stream"
  readonly stream: Stream_.Stream<globalThis.Uint8Array, unknown>
  readonly contentType: string
  readonly contentLength?: number | undefined
}

export interface Uint8Array extends HttpBody.Proto {
  readonly _tag: "Uint8Array"
  readonly body: globalThis.Uint8Array
  readonly contentType: string
  readonly contentLength: number
}

declare const isHttpBody: (u: unknown) => u is HttpBody

declare const ErrorTypeId: unique symbol

type ErrorTypeId = typeof ErrorTypeId

declare const TypeId: unique symbol

type TypeId = typeof TypeId

export interface Proto extends Inspectable {
  readonly [TypeId]: TypeId
  readonly _tag: string
  readonly contentType?: string | undefined
  readonly contentLength?: number | undefined
}

export interface FileLike {
  readonly name: string
  readonly lastModified: number
  readonly size: number
  readonly stream: () => unknown
  readonly type: string
}