export declare const empty: Empty

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

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

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

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

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

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

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

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

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

export declare const uint8Array: (body: globalThis.Uint8Array) => Uint8Array

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

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

export declare const BodyError: (reason: BodyErrorReason) => BodyError

export interface BodyError {
  readonly [ErrorTypeId]: ErrorTypeId
  readonly _tag: "BodyError"
  readonly reason: BodyErrorReason
}

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

export type Body = Empty | Raw | Uint8Array | FormData | Stream

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

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

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

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

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

export declare const isBody: (u: unknown) => u is Body

export declare const ErrorTypeId: typeof ErrorTypeId

export type ErrorTypeId = typeof ErrorTypeId

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

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

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