FileSystem

declare const FileDescriptor: Constructor<Descriptor>;

declare const make: (
  impl: Omit<FileSystem, "exists" | "readFileString" | "stream" | "sink" | "writeFileString">,
) => FileSystem;

declare const makeNoop: (fileSystem: Partial<FileSystem>) => FileSystem;

declare const WatchEventCreate: Data.Case.Constructor<WatchEvent.Create, "_tag">;

declare const WatchEventRemove: Data.Case.Constructor<WatchEvent.Remove, "_tag">;

declare const WatchEventUpdate: Data.Case.Constructor<WatchEvent.Update, "_tag">;

declare class WatchBackend extends any {
  constructor();
}

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

declare const layerNoop: (fileSystem: Partial<FileSystem>) => Layer<FileSystem>;

interface File {
  readonly [FileTypeId]: typeof FileTypeId;
  readonly fd: Descriptor;
  readonly read: (buffer: Uint8Array) => Effect<Size, PlatformError>;
  readonly readAlloc: (
    size: SizeInput,
  ) => Effect<Option<Uint8Array<ArrayBufferLike>>, PlatformError>;
  readonly seek: (offset: SizeInput, from: SeekMode) => Effect<void>;
  readonly stat: Effect<Info, PlatformError>;
  readonly sync: Effect<void, PlatformError>;
  readonly truncate: (length?: SizeInput) => Effect<void, PlatformError>;
  readonly write: (buffer: Uint8Array) => Effect<Size, PlatformError>;
  readonly writeAll: (buffer: Uint8Array) => Effect<void, PlatformError>;
}

interface FileSystem {
  readonly access: (path: string, options?: AccessFileOptions) => Effect<void, PlatformError>;
  readonly chmod: (path: string, mode: number) => Effect<void, PlatformError>;
  readonly chown: (path: string, uid: number, gid: number) => Effect<void, PlatformError>;
  readonly copy: (
    fromPath: string,
    toPath: string,
    options?: CopyOptions,
  ) => Effect<void, PlatformError>;
  readonly copyFile: (fromPath: string, toPath: string) => Effect<void, PlatformError>;
  readonly exists: (path: string) => Effect<boolean, PlatformError>;
  readonly link: (fromPath: string, toPath: string) => Effect<void, PlatformError>;
  readonly makeDirectory: (
    path: string,
    options?: MakeDirectoryOptions,
  ) => Effect<void, PlatformError>;
  readonly makeTempDirectory: (options?: MakeTempDirectoryOptions) => Effect<string, PlatformError>;
  readonly makeTempDirectoryScoped: (
    options?: MakeTempDirectoryOptions,
  ) => Effect<string, PlatformError, Scope>;
  readonly makeTempFile: (options?: MakeTempFileOptions) => Effect<string, PlatformError>;
  readonly makeTempFileScoped: (
    options?: MakeTempFileOptions,
  ) => Effect<string, PlatformError, Scope>;
  readonly open: (path: string, options?: OpenFileOptions) => Effect<File, PlatformError, Scope>;
  readonly readDirectory: (
    path: string,
    options?: ReadDirectoryOptions,
  ) => Effect<Array<string>, PlatformError>;
  readonly readFile: (path: string) => Effect<Uint8Array<ArrayBufferLike>, PlatformError>;
  readonly readFileString: (path: string, encoding?: string) => Effect<string, PlatformError>;
  readonly readLink: (path: string) => Effect<string, PlatformError>;
  readonly realPath: (path: string) => Effect<string, PlatformError>;
  readonly remove: (path: string, options?: RemoveOptions) => Effect<void, PlatformError>;
  readonly rename: (oldPath: string, newPath: string) => Effect<void, PlatformError>;
  readonly sink: (
    path: string,
    options?: SinkOptions,
  ) => Sink<void, Uint8Array<ArrayBufferLike>, never, PlatformError>;
  readonly stat: (path: string) => Effect<Info, PlatformError>;
  readonly stream: (
    path: string,
    options?: StreamOptions,
  ) => Stream<Uint8Array<ArrayBufferLike>, PlatformError>;
  readonly symlink: (fromPath: string, toPath: string) => Effect<void, PlatformError>;
  readonly truncate: (path: string, length?: SizeInput) => Effect<void, PlatformError>;
  readonly utimes: (
    path: string,
    atime: number | Date,
    mtime: number | Date,
  ) => Effect<void, PlatformError>;
  readonly watch: (path: string, options?: WatchOptions) => Stream<WatchEvent, PlatformError>;
  readonly writeFile: (
    path: string,
    data: Uint8Array,
    options?: WriteFileOptions,
  ) => Effect<void, PlatformError>;
  readonly writeFileString: (
    path: string,
    data: string,
    options?: WriteFileStringOptions,
  ) => Effect<void, PlatformError>;
}

type OpenFlag = "r" | "r+" | "w" | "wx" | "w+" | "wx+" | "a" | "ax" | "a+" | "ax+";

type SeekMode = "start" | "current";

type WatchEvent = WatchEvent.Create | WatchEvent.Update | WatchEvent.Remove;

interface AccessFileOptions {
  readonly ok?: boolean;
  readonly readable?: boolean;
  readonly writable?: boolean;
}

interface CopyOptions {
  readonly overwrite?: boolean;
  readonly preserveTimestamps?: boolean;
}

interface MakeDirectoryOptions {
  readonly mode?: number;
  readonly recursive?: boolean;
}

interface MakeTempDirectoryOptions {
  readonly directory?: string;
  readonly prefix?: string;
}

interface MakeTempFileOptions {
  readonly directory?: string;
  readonly prefix?: string;
  readonly suffix?: string;
}

interface OpenFileOptions {
  readonly flag?: OpenFlag;
  readonly mode?: number;
}

interface ReadDirectoryOptions {
  readonly recursive?: boolean;
}

interface RemoveOptions {
  readonly force?: boolean;
  readonly recursive?: boolean;
}

interface SinkOptions extends OpenFileOptions {}

interface StreamOptions {
  readonly bufferSize?: number;
  readonly bytesToRead?: SizeInput;
  readonly chunkSize?: SizeInput;
  readonly offset?: SizeInput;
}

interface WatchOptions {
  readonly recursive?: boolean;
}

interface WriteFileOptions {
  readonly flag?: OpenFlag;
  readonly mode?: number;
}

interface WriteFileStringOptions {
  readonly flag?: OpenFlag;
  readonly mode?: number;
}

declare const GiB: (n: number) => Size;

declare const KiB: (n: number) => Size;

declare const MiB: (n: number) => Size;

declare const PiB: (n: number) => Size;

declare const Size: (bytes: SizeInput) => Size;

type Size = Brand.Branded<bigint, "Size">;

type SizeInput = bigint | number | Size;

declare const TiB: (n: number) => Size;

declare const FileSystem: Tag<FileSystem, FileSystem>;

declare const FileTypeId: unique symbol;

type FileTypeId = typeof FileTypeId;