Multipart

declare function makeConfig(headers: Record<string, string>): Effect<BaseConfig>

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

declare const ErrorTypeId: unique symbol

type ErrorTypeId = typeof ErrorTypeId

declare class MultipartError extends {
  [key: string]: unknown;
  [key: number]: unknown;
  [key: symbol]: unknown;
  readonly _tag: "MultipartError";
} & YieldableError<this> {
  [key: string]: unknown;
  [key: number]: unknown;
  [key: symbol]: unknown;
  constructor(...args: [props: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
    readonly _tag: "MultipartError";
  }, options?: MakeOptions]);
  readonly [ErrorTypeId]: typeof ErrorTypeId;
  message: string;
}

declare class FieldMimeTypes extends any {
  constructor();
}

declare class MaxFieldSize extends any {
  constructor();
}

declare class MaxFileSize extends any {
  constructor();
}

declare class MaxParts extends any {
  constructor();
}

declare const withFieldMimeTypes: {
  (mimeTypes: readonly Array<string>): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
  <A, E, R>(effect: Effect<A, E, R>, mimeTypes: readonly Array<string>): Effect<A, E, R>;
}

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

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

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

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

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

declare function isField(u: unknown): u is Field

declare function isFile(u: unknown): u is File

declare function isPart(u: unknown): u is Part

declare function isPersistedFile(u: unknown): u is PersistedFile

interface Field extends Proto {
  readonly _tag: "Field";
  readonly contentType: string;
  readonly key: string;
  readonly value: string;
}

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

type Part = Field | File

interface Persisted {
  [key: string]: string | readonly Array<string> | readonly Array<PersistedFile>;
}

interface PersistedFile extends Proto {
  readonly _tag: "PersistedFile";
  readonly contentType: string;
  readonly key: string;
  readonly name: string;
  readonly path: string;
}

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

declare function makeChannel<IE>(headers: Record<string, string>, bufferSize: number): Channel<Chunk<Part>, Chunk<Uint8Array<ArrayBufferLike>>, MultipartError | IE, IE, unknown, unknown>

declare const FileSchema: Schema.Schema<PersistedFile>

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

declare function schemaJson<A, I, R>(schema: any, options?: ParseOptions): {
  (field: string): (persisted: Persisted) => Effect<A, ParseError, R>;
  (persisted: Persisted, field: string): Effect<A, ParseError, R>;
}

declare function schemaPersisted<A, I extends Partial<Persisted>, R>(schema: any, options?: ParseOptions): (persisted: Persisted) => Effect<A, ParseError, R>

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

declare const TypeId: unique symbol

type TypeId = typeof TypeId