IO

const IO: Protocol<AnyType, [], IOActions>

enum IO_FLAGS {
  NONE = 0,
  FOLLOW_SYMLINKS = 1 << 2,
  FILES = 1 << 3,
  DIRS = 1 << 4,
  APPEND = 1 << 5,
  EXCLUSIVE = 1 << 6,
}

IO.actions.read(path: PathLike): Future<Uint8Array>

IO.actions.readText(path: PathLike, encoding?: string): Future<string>

IO.actions.write(path: PathLike, data: Uint8Array | string, options?: { flags?: number }): Future<void>

IO.actions.append(path: PathLike, data: Uint8Array): Future<void>

IO.actions.copy(src: PathLike, dest: PathLike, options?: { flags?: number }): Future<void>

IO.actions.rename(src: PathLike, dest: PathLike, options?: { flags?: number }): Future<void>

IO.actions.rm(path: PathLike, options?: { recursive?: boolean; force?: boolean }): Future<void>

IO.actions.exists(path: PathLike): Future<boolean>

IO.actions.stat(path: PathLike): Future<IOStat>

IO.actions.lstat(path: PathLike): Future<IOStat>

IO.actions.readdir(path: PathLike, options?: { recursive?: boolean }): Future<string[]>

IO.actions.ensureDir(path: PathLike): Future<void>

IO.actions.ensureFile(path: PathLike): Future<void>

IO.actions.emptyDir(path: PathLike): Future<void>

IO.actions.walk(root: PathLike, options?: WalkOptions): Future<WalkEntry[]>

IO.actions.watch(path: PathLike, options?: WatchOptions): Stream<WatchEvent, never>

IO.actions.chmod(path: PathLike, mode: number): Future<void>

IO.actions.symlink(target: PathLike, path: PathLike, type?: 'file' | 'dir' | 'junction'): Future<void>

IO.actions.readlink(path: PathLike): Future<string>

IO.actions.readStream(path: PathLike): Stream<Uint8Array, StreamClose>

IO.actions.writeStream(path: PathLike, source: Stream<Uint8Array, unknown>, options?: { flags?: number }): Future<void>

IO.actions.fromReadable(target: ReadableLike, options?: { destroy?: boolean }): Stream<Uint8Array, StreamClose>

IO.actions.toReadable(source: Stream<Uint8Array, unknown>): Future<{ readable: ReadableStream<Uint8Array>; pump: Operation<void> }>

IO.actions.env<R, K extends keyof R = never>(
  mapper: (data: Record<string, string | undefined>) => R,
  optional?: readonly K[],
): Future<{ [P in keyof R]: P extends K ? R[P] : NonNullable<R[P]> }>

IO.actions.exec(cmd: string, args?: readonly string[], options?: ExecOptions): Future<ExecResult>

IO.actions.spawn(cmd: string, args?: readonly string[], options?: SpawnOptions): Future<ProcessHandle>

IO.actions.tcpListen(options: TcpListenOptions, onConnection: TcpHandler): Future<TcpServer>

IO.actions.tcpConnect(options: TcpConnectOptions): Future<TcpSocket>

IO.actions.udpBind(options?: UdpBindOptions): Future<UdpSocket>

IO.actions.ip(): Future<NetworkInterface[]>

IO.actions.randomBytes(length: number): Future<Uint8Array>

IO.actions.ulid(options?: UlidOptions): Future<string>

IO.actions.uuid(): Future<string>

IO.actions.hash(algorithm: HashAlgorithm, data: Uint8Array): Future<Uint8Array>

IO.actions.hmac(algorithm: HashAlgorithm, key: Uint8Array, data: Uint8Array): Future<Uint8Array>

IO.actions.encrypt(data: Uint8Array | string, secret: string): Future<Uint8Array>

IO.actions.decrypt(data: Uint8Array, secret: string): Future<Uint8Array>

IO.actions.generateKeyPair(): Future<KeyPair>

IO.actions.sign(data: Uint8Array | string, privateKey: Uint8Array): Future<Uint8Array>

IO.actions.verify(data: Uint8Array | string, signature: Uint8Array, publicKey: Uint8Array): Future<boolean>

IO.actions.join(...segments: string[]): Future<string>

IO.actions.dirname(path: string): Future<string>

IO.actions.basename(path: string, suffix?: string): Future<string>

IO.actions.extname(path: string): Future<string>

IO.actions.isAbsolute(path: string): Future<boolean>

function toPath(pathOrUrl: PathLike): string

type IOActions = { read: ...; write: ...; exec: ...; /* every action */ }

type PathLike = string | URL

type HashAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512'

type StreamClose = true | Result.Failure<unknown>

interface IOStat {
  isFile: boolean
  isDirectory: boolean
  isSymlink: boolean
  size: number
  mtime: Date | null
  atime: Date | null
  birthtime: Date | null
}

interface WalkEntry {
  path: string
  name: string
  isFile: boolean
  isDirectory: boolean
  isSymlink: boolean
}

interface WatchEvent {
  type: 'rename' | 'change'
  path: string | null
}

interface ProcessStatus {
  code: number | null
  signal: string | null
  success: boolean
}

interface ExecResult extends ProcessStatus {
  stdout: Uint8Array
  stderr: Uint8Array
}

interface ProcessHandle {
  readonly pid: number
  readonly stdout: Stream<Uint8Array, StreamClose>
  readonly stderr: Stream<Uint8Array, StreamClose>
  exited: () => Future<ProcessStatus>
  write: (chunk: Uint8Array | string) => Future<void>
  closeStdin: () => Future<void>
  kill: (signal?: number | string) => Future<void>
}

interface KeyPair {
  publicKey: Uint8Array
  privateKey: Uint8Array
}

interface NetworkInterface {
  name: string
  address: string
  family: 'IPv4' | 'IPv6'
  internal: boolean
  mac: string
  netmask: string
  cidr: string | null
}

interface TcpSocket {
  readonly remoteAddress: string
  readonly remotePort: number
  readonly localPort: number
  data: Stream<Uint8Array, StreamClose>
  write: (chunk: Uint8Array | string) => Future<void>
  close: () => Future<void>
}

type TcpHandler = (socket: TcpSocket) => Operation<void>

interface TcpServer {
  readonly port: number
  readonly hostname: string
  close: () => Future<void>
}

interface UdpDatagram {
  data: Uint8Array
  address: string
  port: number
}

interface UdpSocket {
  readonly port: number
  messages: Stream<UdpDatagram, StreamClose>
  send: (data: Uint8Array | string, port: number, address: string) => Future<void>
  close: () => Future<void>
}

type ReadableLike = NodeReadableLike | WebReadableLike

interface NodeReadableLike {
  on(event: string, listener: (...args: AnyType[]) => void): this
  off(event: string, listener: (...args: AnyType[]) => void): this
  destroy?(error?: Error): this
}

interface WebReadableLike {
  read(): Promise<ReadableStreamReadResult<Uint8Array>>
  cancel(reason?: AnyType): Promise<void>
  releaseLock(): void
}

interface WritableLike {
  write(chunk: Uint8Array): boolean
  end(): this
  destroy?(error?: Error): this
  on(event: string, listener: (...args: AnyType[]) => void): this
  once(event: string, listener: (...args: AnyType[]) => void): this
  off(event: string, listener: (...args: AnyType[]) => void): this
}

interface WalkOptions {
  flags?: number
  maxDepth?: number
  match?: RegExp[]
  skip?: RegExp[]
}

interface WatchOptions {
  recursive?: boolean
}

interface UlidOptions {
  window?: number
  length?: number
  bucket?: string
}

interface ProcessOptions {
  cwd?: PathLike
  env?: Record<string, string | undefined>
}

interface ExecOptions extends ProcessOptions {
  stdin?: Uint8Array | string
  timeout?: number
}

type SpawnOptions = ProcessOptions

interface TcpListenOptions {
  port: number
  hostname?: string
  reusePort?: boolean
}

interface TcpConnectOptions {
  port: number
  hostname?: string
}

interface UdpBindOptions {
  port?: number
  hostname?: string
}