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

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

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

export declare const MultipartError: (reason: MultipartError["reason"], error: unknown) => MultipartError

export interface MultipartError extends Data.Case {
  readonly [ErrorTypeId]: ErrorTypeId
  readonly _tag: "MultipartError"
  readonly reason: "FileTooLarge" | "FieldTooLarge" | "BodyTooLarge" | "TooManyParts" | "InternalError" | "Parse"
  readonly error: unknown
}

export declare const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>>

export declare const maxFieldSize: FiberRef.FiberRef<FileSystem.Size>

export declare const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>>

export declare const maxParts: FiberRef.FiberRef<Option.Option<number>>

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

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

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

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

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<never, MultipartError, Uint8Array>
}

export type Part = Field | File

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

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

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

export declare const filesSchema: Schema.Schema<readonly PersistedFile[], readonly PersistedFile[]>

export declare const schemaJson: <I, A>(
  schema: Schema.Schema<I, A>
) => {
  (field: string): (persisted: Persisted) => Effect.Effect<never, ParseResult.ParseError, A>
  (persisted: Persisted, field: string): Effect.Effect<never, ParseResult.ParseError, A>
}

export declare const schemaPersisted: <I extends Persisted, A>(
  schema: Schema.Schema<I, A>
) => (persisted: Persisted) => Effect.Effect<never, ParseResult.ParseError, A>

export declare const ErrorTypeId: typeof ErrorTypeId

export type ErrorTypeId = typeof ErrorTypeId

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

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