HttpBody

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 json: (body: unknown, contentType?: string) => Effect.Effect<Uint8Array, HttpBodyError>

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

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

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

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

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

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

declare const urlParams: (urlParams: UrlParams.UrlParams, contentType?: string) => Uint8Array

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

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

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

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

type FormDataCoercible = string | number | boolean | File | Blob | null | undefined

type FormDataInput = Record<string, FormDataCoercible | ReadonlyArray<FormDataCoercible>>

declare const formDataRecord: (entries: FormDataInput) => FormData

interface Empty extends Proto {
  readonly _tag: "Empty";
}

interface FormData extends Proto {
  readonly _tag: "FormData";
  readonly formData: FormData;
}

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

interface Raw extends Proto {
  readonly _tag: "Raw";
  readonly body: unknown;
}

interface Stream extends Proto {
  readonly _tag: "Stream";
  readonly contentLength?: number;
  readonly contentType: string;
  readonly stream: Stream<Uint8Array<ArrayBufferLike>, unknown>;
}

interface Uint8Array extends Proto {
  readonly _tag: "Uint8Array";
  readonly body: Uint8Array;
  readonly contentLength: number;
  readonly contentType: string;
}

declare function isHttpBody(u: unknown): u is HttpBody

declare const ErrorTypeId: unique symbol

type ErrorTypeId = typeof ErrorTypeId

declare const TypeId: unique symbol

type TypeId = typeof TypeId