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;