declare const makeConfig: (headers: Record<string, string>) => Effect.Effect<MP.BaseConfig>

declare const toPersisted: (
  stream: Stream.Stream<Part, MultipartError>,
  writeFile?: (path: string, file: File) => Effect.Effect<void, MultipartError, FileSystem.FileSystem>
) => Effect.Effect<Persisted, MultipartError, FileSystem.FileSystem | Path.Path | Scope.Scope>

declare const ErrorTypeId: unique symbol

type ErrorTypeId = typeof ErrorTypeId

declare class MultipartError

readonly [ErrorTypeId]: unique symbol

declare const isField: (u: unknown) => u is Field

declare const isFile: (u: unknown) => u is File

declare const isPart: (u: unknown) => u is Part

declare const isPersistedFile: (u: unknown) => u is PersistedFile

declare const makeChannel: <IE>(
  headers: Record<string, string>,
  bufferSize?: number
) => Channel.Channel<Chunk.Chunk<Part>, Chunk.Chunk<Uint8Array>, MultipartError | IE, IE, unknown, unknown>

declare const FileSchema: Schema.Schema<PersistedFile, PersistedFile, never>

declare const FilesSchema: Schema.Schema<ReadonlyArray<PersistedFile>, ReadonlyArray<PersistedFile>, never>

declare const SingleFileSchema: Schema.transform<
  Schema.Schema<ReadonlyArray<PersistedFile>, ReadonlyArray<PersistedFile>, never>,
  Schema.Schema<PersistedFile, PersistedFile, never>
>

declare const schemaJson: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => {
  (field: string): (persisted: Persisted) => Effect.Effect<A, ParseResult.ParseError, R>
  (persisted: Persisted, field: string): Effect.Effect<A, ParseResult.ParseError, R>
}

declare const schemaPersisted: <A, I extends Partial<Persisted>, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => (persisted: Persisted) => Effect.Effect<A, ParseResult.ParseError, R>

declare class FieldMimeTypes

declare class MaxFieldSize

declare class MaxFileSize

declare class MaxParts

declare const withFieldMimeTypes: {
  (mimeTypes: ReadonlyArray<string>): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <A, E, R>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>): Effect.Effect<A, E, R>
}

declare const withLimits: {
  (options: {
    readonly maxParts?: Option.Option<number> | undefined
    readonly maxFieldSize?: FileSystem.SizeInput | undefined
    readonly maxFileSize?: Option.Option<FileSystem.SizeInput> | undefined
    readonly maxTotalSize?: Option.Option<FileSystem.SizeInput> | undefined
    readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
  }): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <A, E, R>(
    effect: Effect.Effect<A, E, R>,
    options: {
      readonly maxParts?: Option.Option<number> | undefined
      readonly maxFieldSize?: FileSystem.SizeInput | undefined
      readonly maxFileSize?: Option.Option<FileSystem.SizeInput> | undefined
      readonly maxTotalSize?: Option.Option<FileSystem.SizeInput> | undefined
      readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
    }
  ): Effect.Effect<A, E, R>
}

type Options = {
  readonly maxParts?: Option.Option<number> | undefined
  readonly maxFieldSize?: FileSystem.SizeInput | undefined
  readonly maxFileSize?: Option.Option<FileSystem.SizeInput> | undefined
  readonly maxTotalSize?: Option.Option<FileSystem.SizeInput> | undefined
  readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
}

declare const withLimitsStream: {
  (options: {
    readonly maxParts?: Option.Option<number> | undefined
    readonly maxFieldSize?: FileSystem.SizeInput | undefined
    readonly maxFileSize?: Option.Option<FileSystem.SizeInput> | undefined
    readonly maxTotalSize?: Option.Option<FileSystem.SizeInput> | undefined
    readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
  }): <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>
  <A, E, R>(
    stream: Stream.Stream<A, E, R>,
    options: {
      readonly maxParts?: Option.Option<number> | undefined
      readonly maxFieldSize?: FileSystem.SizeInput | undefined
      readonly maxFileSize?: Option.Option<FileSystem.SizeInput> | undefined
      readonly maxTotalSize?: Option.Option<FileSystem.SizeInput> | undefined
      readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
    }
  ): Stream.Stream<A, E, R>
}

declare const withMaxFieldSize: {
  (size: FileSystem.SizeInput): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <A, E, R>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput): Effect.Effect<A, E, R>
}

declare const withMaxFileSize: {
  (size: Option.Option<FileSystem.SizeInput>): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <A, E, R>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>): Effect.Effect<A, E, R>
}

declare const withMaxParts: {
  (count: Option.Option<number>): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <A, E, R>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>): Effect.Effect<A, E, R>
}

export interface Field extends Part.Proto {
  readonly _tag: "Field"
  readonly key: string
  readonly contentType: string
  readonly value: string
}

export interface File extends Part.Proto {
  readonly _tag: "File"
  readonly key: string
  readonly name: string
  readonly contentType: string
  readonly content: Stream.Stream<Uint8Array, MultipartError>
  readonly contentEffect: Effect.Effect<Uint8Array, MultipartError>
}

type Part = Field | File

export interface Persisted {
  readonly [key: string]: ReadonlyArray<PersistedFile> | ReadonlyArray<string> | string
}

export interface PersistedFile extends Part.Proto {
  readonly _tag: "PersistedFile"
  readonly key: string
  readonly name: string
  readonly contentType: string
  readonly path: string
}

declare const TypeId: unique symbol

type TypeId = typeof TypeId

export interface Proto extends Inspectable.Inspectable {
  readonly [TypeId]: TypeId
  readonly _tag: string
}

declare const collectUint8Array: Channel.Channel<
  never,
  Chunk.Chunk<Uint8Array<ArrayBufferLike>>,
  unknown,
  unknown,
  Uint8Array<ArrayBufferLike>,
  unknown,
  never
>