fs.readFile(path: string, useBuffer: boolean?): (boolean, string | buffer | FileReadError)

fs.readDir(path: string): (boolean, { string } | string)

fs.writeFile(path: string, contents: buffer | string): (boolean, FileWriteError?)

fs.writeDir(path: string, recursive: boolean?): (boolean, DirWriteError?)

fs.removeFile(path: string): (boolean, FileRemoveError?)

fs.removeDir(path: string, recursive: boolean?): (boolean, DirRemoveError?)

fs.metadata(path: string): (boolean, Metadata? | MetadataError)

fs.isFile(path: string): boolean

fs.isDir(path: string): boolean

fs.move(from: string, to: string, overwrite: boolean?): (boolean, MoveError?)

fs.copy(from: string, to: string, overwrite: boolean?): (boolean, CopyError?)

fs.symlink(from: string, to: string): (boolean, SymlinkError?)

fs.watch(path: string, callback: (path: string, events: {"created" | "modified" | "moved" | "renamed" | "deleted" | "metadata"}) -> ()): FileWatcher

fs.openFile(path: string, opts: OpenFileOptions?): (boolean, FileHandle | FileReadError);

fs.createFile(path: string, opts: CreateFileOptions?): (boolean, FileHandle | FileReadError);

type IOError = "AccessDenied"
| "FileNotFound"
| "UnknownError"

type DiskError = "DiskQuotaExceeded"

type FileError = "Aborted"

type DeviceError = "Busy"

type ReadError = "OutOfMemory"

type NetworkError = "NetworkNotFound"

type EncodingError = "InvalidUtf-8"
| "InvalidWtf-8"

export type FileReadError = IOError
| FileError
| DeviceError
| ReadError
| "NotFile"
| "NotOpenForReading"
| "FailedToCreateBuffer"

export type FileWriteError = IOError
| DiskError
| FileError
| DeviceError
| "TooBig"
| "OutOfSpace"
| "Locked"
| "NotOpenForWriting"
| "FailedToWriteBuffer"

export type DirWriteError = IOError
| DiskError
| NetworkError
| EncodingError
| "BadName"
| "TooLong"
| "SymbolicLinkLoop"
| "PathAlreadyExists"
| "SymbolicLinkQuotaExceeded"

export type FileRemoveError = IOError
| DeviceError
| "NotFile"

export type DirRemoveError = IOError
| DeviceError
| "NotDirectory"
| "DirNotEmpty"

export type MetadataError = IOError
| DeviceError

export type MetadataKind = "file"
	| "dir"
	| "symlink"
	| "door"
	| "character_device"
	| "unix_domain_socket"
	| "block_device"
	| "event_port"
	| "named_pipe"
	| "whiteout"
	| "unknown"

export type Metadata = {
	kind : MetadataKind,
	symlink : boolean,
	createdAt : number,
	modifiedAt : number,
	accessedAt : number,
	size : number,
	permissions : {
		readOnly : boolean,
	},
}

export type MoveError = IOError
| DeviceError
| DiskError
| NetworkError
| EncodingError
| "NotFile"
| "NotDirectory"
| "PathAlreadyExists"
| "DirNotEmpty"
| "SymbolicLinkLoop"
| "SharingViolation"
| "TooLong"
| "AntivirusInterference"
| "BadName"

export type CopyError = IOError
| DeviceError

export type SymlinkError = IOError
| DiskError
| EncodingError
| NetworkError
| "TooLong"
| "PathAlreadyExists"
| "BadName"
| "NotDirectory"
| "OutOfSpace"
| "SymbolicLinkLoop"
| "NotDirectory"
| "NotFile"
| "NotSupported"

export type FileWatcher = {
	--[[
		Stops the watcher.
	]]
	stop : (self: FileWatcher) -> (),
}

 
export type FileHandle = {
	--[[
		Reads the contents of a file.
 
		*Optional: The amount of bytes to read, if nil, reads the whole till EOF or Luau limit.*
 
		@param amount The amount of bytes to read.
	]]
	read :
		& ((self: FileHandle, amount: number?, useBuffer: false?) -> string)
		& ((self: FileHandle, amount: number?, useBuffer: true) -> buffer),
 
 
	--[[
		Writes to a file.
 
		@param contents The contents to write to the file.
	]]
	write : (self: FileHandle, contents: buffer | string) -> (),
 
	--[[
		Appends to a file.
		
		@param contents The contents to append to the file.
	]]
	append : (self: FileHandle, contents: buffer | string) -> (),
 
	--[[
		Returns the size of the file. Based on current state of the file object.
	]]
	getSize : (self: FileHandle) -> number,
 
	--[[
		Returns the current position of the file.
	]]
	getSeekPosition : (self: FileHandle) -> number,
 
	--[[
		Seeks to a position in the file relative to the end.
 
		*Optional: The amount of bytes to seek, if nil, seeks to the end*
 
		@param amount The amount of bytes to seek.
	]]
	seekFromEnd : (self: FileHandle, amount: number?) -> (),
 
	--[[
		Seeks to a position in the file absolute to the start.
 
		*Optional: The amount of bytes to seek, if nil, seeks to the start, 0*
 
		@param amount The amount of bytes to seek.
	]]
	seekTo : (self: FileHandle, amount: number?) -> (),
 
	--[[
		Seeks to a position in the file relative to the current position.
 
		*Optional: The amount of bytes to seek, if nil, seeks to the next position, 1*
 
		*If `0` is provided, seek will not move.*
 
		@param amount The amount of bytes to seek.
	]]
	seekBy : (self: FileHandle, amount: number?) -> (),
 
	--[[
		Locks the file.
 
		*Optional: The mode to lock the file, if nil, locks the file in exclusive mode.*
 
		@param lockMode The mode to lock the file.
	]]
	lock : (self: FileHandle, lockMode: ("shared" | "exclusive" | "none")?) -> boolean,
 
	--[[
		Unlocks the file.
	]]
	unlock : (self: FileHandle) -> (),
 
	--[[
		Flushes the file. Writes the contents to the disk.
 
		Does not yield, **blocks** process.
	]]
	sync : (self: FileHandle) -> (),
 
	--[[
		Closes the file. (Will flush the file)
	]]
	close : (self: FileHandle) -> (),
}

type OpenFileOptions = {
	--[[
		The mode to open the file in.
 
		Available modes: `r`, `w`
 
		*Default: `rw`*
	]]
	mode : string?,
}

type CreateFileOptions = {
	--[[
		Whether to create the file in exclusive mode.
 
		*Default: false*
	]]
	exclusive : boolean?,
}