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 any {
  constructor();
  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;