File System API reference

Returns `true` if the `fs.Dirent` object describes a regular file.

isFile(): boolean

Returns `true` if the `fs.Dirent` object describes a file system directory.

isDirectory(): boolean

Returns `true` if the `fs.Dirent` object describes a block device.

isBlockDevice(): boolean

Returns `true` if the `fs.Dirent` object describes a character device.

isCharacterDevice(): boolean

Returns `true` if the `fs.Dirent` object describes a symbolic link.

isSymbolicLink(): boolean

Returns `true` if the `fs.Dirent` object describes a first-in-first-out (FIFO) pipe.

isFIFO(): boolean

Returns `true` if the `fs.Dirent` object describes a socket.

isSocket(): boolean

The file name that this `fs.Dirent` object refers to. The type of this value is determined by the `options.encoding` passed to or .

name: Name

The path to the parent directory of the file this `fs.Dirent` object refers to.

parentPath: string

Alias for `dirent.parentPath`.

path: string

promises: this

constants: FSConstants

constructor(): MemoryFileSystem

init(): Promise<void>

readFile(path: string, options?: { encoding?: BufferEncoding; flag?: string; } | BufferEncoding): Promise<Buffer | string>

writeFile(path: string, data: Buffer | string | Uint8Array, options?: { encoding?: BufferEncoding; mode?: number; flag?: string; }): Promise<void>

copyFile(src: string, dest: string, mode?: number): Promise<void>

appendFile(path: string, data: Buffer | string | Uint8Array, options?: { encoding?: BufferEncoding; mode?: number; flag?: string; }): Promise<void>

mkdir(path: string, options?: { recursive?: boolean; mode?: number; }): Promise<string | undefined>

readdir(path: string, options?: { encoding?: BufferEncoding; withFileTypes?: false; recursive?: boolean; }): Promise<string[]>

readdir(path: string, options: { encoding?: BufferEncoding; withFileTypes: true; recursive?: boolean; }): Promise<Dirent[]>

readdir(path: string, options?: { encoding?: BufferEncoding; withFileTypes?: boolean; recursive?: boolean; }): Promise<string[] | Dirent[]>

rmdir(path: string, options?: { maxRetries?: number; recursive?: boolean; retryDelay?: number; }): Promise<void>

stat(path: string, options?: { bigint?: false; }): Promise<Stats>

stat(path: string, options: { bigint: true; }): Promise<BigIntStats>

stat(path: string, options?: { bigint?: boolean; }): Promise<Stats | BigIntStats>

lstat(path: string, options?: { bigint?: false; }): Promise<Stats>

lstat(path: string, options: { bigint: true; }): Promise<BigIntStats>

lstat(path: string, options?: { bigint?: boolean; }): Promise<Stats | BigIntStats>

rename(oldPath: string, newPath: string): Promise<void>

unlink(path: string): Promise<void>

exists(path: string): Promise<boolean>

access(path: string, mode?: number): Promise<void>

chmod(path: string, mode: string | number): Promise<void>

chown(path: string, uid: number, gid: number): Promise<void>

readlink(path: string, options?: { encoding?: BufferEncoding; }): Promise<string>

symlink(target: string, path: string, type?: "dir" | "file" | "junction"): Promise<void>

link(existingPath: string, newPath: string): Promise<void>

truncate(path: string, len?: number): Promise<void>

utimes(path: string, atime: string | number | Date, mtime: string | number | Date): Promise<void>

rm(path: string, options?: { force?: boolean; maxRetries?: number; recursive?: boolean; retryDelay?: number; }): Promise<void>

open(path: string, flags?: string | number, mode?: number): Promise<IFileHandle>

opendir(path: string, options?: { encoding?: BufferEncoding; bufferSize?: number; recursive?: boolean; }): Promise<IDir>

realpath(path: string, options?: { encoding?: BufferEncoding; }): Promise<string>

cp(src: string, dest: string, options?: { dereference?: boolean; errorOnExist?: boolean; filter?: (src: string, dest: string) => boolean | Promise<boolean>; force?: boolean; mode?: number; preserveTimestamps?: boolean; recursive?: boolean; verbatimSymlinks?: boolean; }): Promise<void>

mkdtemp(prefix: string, options?: { encoding?: BufferEncoding; }): Promise<string>

statfs(path: string, options?: { bigint?: false; }): Promise<StatFs>

statfs(path: string, options: { bigint: true; }): Promise<BigIntStatFs>

statfs(path: string, options?: { bigint?: boolean; }): Promise<StatFs | BigIntStatFs>

lutimes(path: string, atime: string | number | Date, mtime: string | number | Date): Promise<void>

lchown(path: string, uid: number, gid: number): Promise<void>

lchmod(path: string, mode: string | number): Promise<void>

createReadStream(path: string, options?: ReadStreamOptions): ReadStream

createWriteStream(path: string, options?: WriteStreamOptions): WriteStream

watch(path: string, options?: { encoding?: BufferEncoding; persistent?: boolean; recursive?: boolean; }): FSWatcher

isImplemented(method: string): boolean

_getNode(path: string): MemoryNode | undefined

dev: number

ino: number

mode: number

nlink: number

uid: number

gid: number

rdev: number

size: number

blksize: number

blocks: number

atime: Date

mtime: Date

ctime: Date

birthtime: Date

isFile(): boolean

isDirectory(): boolean

isBlockDevice(): boolean

isCharacterDevice(): boolean

isSymbolicLink(): boolean

isFIFO(): boolean

isSocket(): boolean

constructor(stats: MemoryStats): MemoryBigIntStats

isFile(): boolean

isDirectory(): boolean

isBlockDevice(): boolean

isCharacterDevice(): boolean

isSymbolicLink(): boolean

isFIFO(): boolean

isSocket(): boolean

name: string

constructor(name: string, type: "file" | "directory"): MemoryDirent

isFile(): boolean

isDirectory(): boolean

isBlockDevice(): boolean

isCharacterDevice(): boolean

isSymbolicLink(): boolean

isFIFO(): boolean

isSocket(): boolean

fd: number

constructor(fd: number, path: string, fs: MemoryFileSystem, node: MemoryNode, canRead: boolean, canWrite: boolean, append: boolean): MemoryFileHandle

appendFile(data: string | Uint8Array, options?: { encoding?: BufferEncoding; }): Promise<void>

chmod(mode: number): Promise<void>

chown(uid: number, gid: number): Promise<void>

close(): Promise<void>

createReadStream(options?: { encoding?: BufferEncoding; start?: number; end?: number; }): ReadStream

createWriteStream(options?: { encoding?: BufferEncoding; start?: number; }): WriteStream

datasync(): Promise<void>

read(buffer: Buffer | Uint8Array, offset?: number, length?: number, position?: number | null): Promise<{ bytesRead: number; buffer: Buffer | Uint8Array; }>

readFile(options?: { encoding?: BufferEncoding; flag?: string; } | BufferEncoding): Promise<Buffer | string>

readLines(options?: { encoding?: BufferEncoding; }): any

stat(options?: { bigint?: false; }): Promise<Stats>

stat(options: { bigint: true; }): Promise<BigIntStats>

stat(options?: { bigint?: boolean; }): Promise<Stats | BigIntStats>

sync(): Promise<void>

truncate(len?: number): Promise<void>

utimes(atime: string | number | Date, mtime: string | number | Date): Promise<void>

write(bufferOrData: Buffer | Uint8Array | string, offsetOrPosition?: number | null, lengthOrEncoding?: number | BufferEncoding, position?: number | null): Promise<{ bytesWritten: number; buffer: any; }>

writeFile(data: string | Uint8Array, options?: { encoding?: BufferEncoding; }): Promise<void>

[Symbol.asyncDispose](): Promise<void>

path: string

constructor(path: string, entries: Dirent[]): MemoryDir

close(): Promise<void>

read(): Promise<Dirent | null>

[Symbol.asyncIterator](): AsyncIterableIterator<Dirent>

constructor(path: string): MemoryWatcher

close(): Promise<void>

addListener(event: string | symbol, listener: (...args: any[]) => void): this

on(event: string | symbol, listener: (...args: any[]) => void): this

once(event: string | symbol, listener: (...args: any[]) => void): this

removeListener(event: string | symbol, listener: (...args: any[]) => void): this

off(event: string | symbol, listener: (...args: any[]) => void): this

removeAllListeners(event?: string | symbol): this

setMaxListeners(n: number): this

getMaxListeners(): number

listeners(event: string | symbol): Function[]

rawListeners(event: string | symbol): Function[]

emit(event: string | symbol, ...args: any[]): boolean

listenerCount(event: string | symbol): number

prependListener(event: string | symbol, listener: (...args: any[]) => void): this

prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this

eventNames(): Array<string | symbol>

constructor(content: Buffer): MemoryReadStream

_read(size: number): void

close(): void

constructor(onFinish: (content: Buffer) => void): MemoryWriteStream

_write(chunk: Buffer, encoding: string, callback: (error?: Error) => void): void

_final(callback: (error?: Error) => void): void

close(): void

close(): void

close(): void

close(): Promise<void>

File is visible to the calling process

F_OK: 0

File can be read by the calling process

R_OK: 4

File can be written by the calling process

W_OK: 2

File can be executed by the calling process

X_OK: 1

Flag for copyFile: fail if dest exists

COPYFILE_EXCL: 1

Open for reading only

O_RDONLY: 0

Open for writing only

O_WRONLY: 1

Open for reading and writing

O_RDWR: 2

Create file if it does not exist

O_CREAT: 64

Fail if O_CREAT and file exists

O_EXCL: 128

Truncate file to zero length

O_TRUNC: 512

Append to end of file

O_APPEND: 1024

The numeric file descriptor

fd: number

appendFile(data: string | Uint8Array, options?: { encoding?: BufferEncoding; }): Promise<void>

chmod(mode: number): Promise<void>

chown(uid: number, gid: number): Promise<void>

close(): Promise<void>

createReadStream(options?: { encoding?: BufferEncoding; start?: number; end?: number; }): ReadStream

createWriteStream(options?: { encoding?: BufferEncoding; start?: number; }): WriteStream

datasync(): Promise<void>

read(buffer: Buffer | Uint8Array, offset?: number, length?: number, position?: number | null): Promise<{ bytesRead: number; buffer: Buffer | Uint8Array; }>

readFile(options?: { encoding?: BufferEncoding; flag?: string; } | BufferEncoding): Promise<Buffer | string>

readLines(options?: { encoding?: BufferEncoding; }): any

stat(options?: { bigint?: false; }): Promise<Stats>

stat(options: { bigint: true; }): Promise<BigIntStats>

sync(): Promise<void>

truncate(len?: number): Promise<void>

utimes(atime: string | number | Date, mtime: string | number | Date): Promise<void>

write(buffer: Buffer | Uint8Array, offset?: number, length?: number, position?: number | null): Promise<{ bytesWritten: number; buffer: Buffer | Uint8Array; }>

write(data: string, position?: number | null, encoding?: BufferEncoding): Promise<{ bytesWritten: number; buffer: string; }>

writeFile(data: string | Uint8Array, options?: { encoding?: BufferEncoding; }): Promise<void>

[Symbol.asyncDispose](): Promise<void>

path: string

close(): Promise<void>

read(): Promise<Dirent | null>

[Symbol.asyncIterator](): AsyncIterableIterator<Dirent>

Optimal transfer block size

bsize: number

Total data blocks in filesystem

blocks: number

Free blocks in filesystem

bfree: number

Available blocks for unprivileged users

bavail: number

Total file nodes in filesystem

files: number

Free file nodes in filesystem

ffree: number

Filesystem type

type: number

bsize: bigint

blocks: bigint

bfree: bigint

bavail: bigint

files: bigint

ffree: bigint

type: bigint

promises: this

constants: FSConstants

readFile(path: string, options?: { encoding?: BufferEncoding; flag?: string; } | BufferEncoding): Promise<Buffer | string>

writeFile(path: string, data: Buffer | string | Uint8Array, options?: { encoding?: BufferEncoding; mode?: number; flag?: string; }): Promise<void>

appendFile(path: string, data: Buffer | string | Uint8Array, options?: { encoding?: BufferEncoding; mode?: number; flag?: string; }): Promise<void>

copyFile(src: string, dest: string, mode?: number): Promise<void>

mkdir(path: string, options?: { recursive?: boolean; mode?: number; }): Promise<string | undefined>

readdir(path: string, options?: { encoding?: BufferEncoding; withFileTypes?: false; recursive?: boolean; }): Promise<string[]>

readdir(path: string, options: { encoding?: BufferEncoding; withFileTypes: true; recursive?: boolean; }): Promise<Dirent[]>

rmdir(path: string, options?: { maxRetries?: number; recursive?: boolean; retryDelay?: number; }): Promise<void>

stat(path: string, options?: { bigint?: false; }): Promise<Stats>

stat(path: string, options: { bigint: true; }): Promise<BigIntStats>

lstat(path: string, options?: { bigint?: false; }): Promise<Stats>

lstat(path: string, options: { bigint: true; }): Promise<BigIntStats>

access(path: string, mode?: number): Promise<void>

rename(oldPath: string, newPath: string): Promise<void>

unlink(path: string): Promise<void>

truncate(path: string, len?: number): Promise<void>

utimes(path: string, atime: string | number | Date, mtime: string | number | Date): Promise<void>

chmod(path: string, mode: string | number): Promise<void>

chown(path: string, uid: number, gid: number): Promise<void>

readlink(path: string, options?: { encoding?: BufferEncoding; }): Promise<string>

symlink(target: string, path: string, type?: "dir" | "file" | "junction"): Promise<void>

link(existingPath: string, newPath: string): Promise<void>

createReadStream(path: string, options?: { encoding?: BufferEncoding; start?: number; end?: number; }): ReadStream

createWriteStream(path: string, options?: { encoding?: BufferEncoding; flags?: string; mode?: number; }): WriteStream

watch(path: string, options?: { encoding?: BufferEncoding; persistent?: boolean; recursive?: boolean; }): FSWatcher

rm(path: string, options?: { force?: boolean; maxRetries?: number; recursive?: boolean; retryDelay?: number; }): Promise<void>

open(path: string, flags?: string | number, mode?: number): Promise<IFileHandle>

opendir(path: string, options?: { encoding?: BufferEncoding; bufferSize?: number; recursive?: boolean; }): Promise<IDir>

realpath(path: string, options?: { encoding?: BufferEncoding; }): Promise<string>

cp(src: string, dest: string, options?: { dereference?: boolean; errorOnExist?: boolean; filter?: (src: string, dest: string) => boolean | Promise<boolean>; force?: boolean; mode?: number; preserveTimestamps?: boolean; recursive?: boolean; verbatimSymlinks?: boolean; }): Promise<void>

mkdtemp(prefix: string, options?: { encoding?: BufferEncoding; }): Promise<string>

statfs(path: string, options?: { bigint?: false; }): Promise<StatFs>

statfs(path: string, options: { bigint: true; }): Promise<BigIntStatFs>

lutimes(path: string, atime: string | number | Date, mtime: string | number | Date): Promise<void>

lchown(path: string, uid: number, gid: number): Promise<void>

lchmod(path: string, mode: string | number): Promise<void>

exists(path: string): Promise<boolean>

isImplemented(method: string): boolean

init(options?: { encoding?: string; }): Promise<void>

atimeNs: bigint

mtimeNs: bigint

ctimeNs: bigint

birthtimeNs: bigint

Unique identifier for this provider instance

id: string

Human-readable display name

name: string

List of capabilities this provider supports

capabilities: readonly CapabilityType[]

Get a capability by type. Returns undefined if the capability is not supported.

<T>(type: CapabilityType): T | undefined

Check if this provider supports a given capability.

hasCapability(type: CapabilityType): boolean

Initialize the provider (e.g., authenticate, establish connections).

initialize(): Promise<void>

Dispose of the provider and release resources.

dispose(): Promise<void>

Size in bytes

size: number

Last modified date

lastModified: Date

Content type (MIME)

contentType: string

ETag for conditional operations

etag: string

Custom metadata key-value pairs

metadata: Record<string, string>

Filter by key prefix

prefix: string

Delimiter for virtual directory grouping

delimiter: string

Maximum number of results

maxKeys: number

Continuation token for pagination

continuationToken: string

Object keys and metadata

objects: { key: string; metadata: ObjectMetadata; }[]

Common prefixes (virtual directories) when delimiter is used

commonPrefixes: string[]

Whether more results are available

isTruncated: boolean

Token to fetch next page

nextContinuationToken: string

Content type (MIME)

contentType: string

Custom metadata

metadata: Record<string, string>

Cache-Control header

cacheControl: string

Expiration time in seconds (default: 3600)

expiresIn: number

HTTP method for the presigned URL

method: "GET" | "PUT"

name: string

creationDate: Date

listBuckets(): Promise<BucketInfo[]>

createBucket(name: string): Promise<void>

deleteBucket(name: string): Promise<void>

bucketExists(name: string): Promise<boolean>

getObject(bucket: string, key: string): Promise<Buffer>

putObject(bucket: string, key: string, data: Buffer | Uint8Array | string, options?: PutObjectOptions): Promise<void>

deleteObject(bucket: string, key: string): Promise<void>

headObject(bucket: string, key: string): Promise<ObjectMetadata>

copyObject(sourceBucket: string, sourceKey: string, destBucket: string, destKey: string): Promise<void>

listObjects(bucket: string, options?: ListObjectsOptions): Promise<ListObjectsResult>

getPresignedUrl(bucket: string, key: string, options?: PresignedUrlOptions): Promise<string>

objectExists(bucket: string, key: string): Promise<boolean>

sha: string

message: string

author: { name: string; email: string; date: Date; }

committer: { name: string; email: string; date: Date; }

parents: string[]

name: string

sha: string

isDefault: boolean

isProtected: boolean

name: string

sha: string

message: string

path: string

status: "added" | "modified" | "deleted" | "renamed"

additions: number

deletions: number

patch: string

previousPath: string

Branch or ref to list commits from

ref: string

Maximum number of commits

maxCount: number

Only commits affecting this path

path: string

Commits after this date

since: Date

Commits before this date

until: Date

listBranches(): Promise<GitBranch[]>

getBranch(name: string): Promise<GitBranch>

createBranch(name: string, sha: string): Promise<GitBranch>

deleteBranch(name: string): Promise<void>

listCommits(options?: ListCommitsOptions): Promise<GitCommit[]>

getCommit(sha: string): Promise<GitCommit>

listTags(): Promise<GitTag[]>

createTag(name: string, sha: string, message?: string): Promise<GitTag>

deleteTag(name: string): Promise<void>

diff(base: string, head: string): Promise<GitDiffEntry[]>

resolveRef(ref: string): Promise<string>

number: number

title: string

body: string

state: PullRequestState

head: { ref: string; sha: string; }

base: { ref: string; sha: string; }

author: string

createdAt: Date

updatedAt: Date

mergedAt: Date

labels: string[]

reviewers: string[]

number: number

title: string

body: string

state: IssueState

author: string

createdAt: Date

updatedAt: Date

labels: string[]

assignees: string[]

id: number

author: string

state: "approved" | "changes_requested" | "commented" | "pending"

body: string

submittedAt: Date

id: number

tagName: string

name: string

body: string

draft: boolean

prerelease: boolean

createdAt: Date

publishedAt: Date

id: number

name: string

status: "queued" | "in_progress" | "completed"

conclusion: "success" | "failure" | "cancelled" | "skipped"

branch: string

sha: string

createdAt: Date

updatedAt: Date

url: string

state: PullRequestState | "all"

head: string

base: string

sort: "created" | "updated" | "popularity"

direction: "asc" | "desc"

maxResults: number

state: IssueState | "all"

labels: string[]

assignee: string

sort: "created" | "updated" | "comments"

direction: "asc" | "desc"

maxResults: number

title: string

body: string

head: string

base: string

draft: boolean

labels: string[]

reviewers: string[]

title: string

body: string

labels: string[]

assignees: string[]

listPullRequests(options?: ListPullRequestsOptions): Promise<PullRequest[]>

getPullRequest(number: number): Promise<PullRequest>

createPullRequest(options: CreatePullRequestOptions): Promise<PullRequest>

updatePullRequest(number: number, updates: Partial<Pick<PullRequest, "title" | "body" | "state" | "labels">>): Promise<PullRequest>

mergePullRequest(number: number, options?: { method?: "merge" | "squash" | "rebase"; commitMessage?: string; }): Promise<void>

listIssues(options?: ListIssuesOptions): Promise<Issue[]>

getIssue(number: number): Promise<Issue>

createIssue(options: CreateIssueOptions): Promise<Issue>

updateIssue(number: number, updates: Partial<Pick<Issue, "title" | "body" | "state" | "labels" | "assignees">>): Promise<Issue>

listReviews(pullRequestNumber: number): Promise<Review[]>

createReview(pullRequestNumber: number, review: { body: string; event: "approve" | "request_changes" | "comment"; }): Promise<Review>

listReleases(): Promise<Release[]>

createRelease(options: { tagName: string; name: string; body: string; draft?: boolean; prerelease?: boolean; }): Promise<Release>

listPipelineRuns(options?: { branch?: string; status?: string; }): Promise<PipelineRun[]>

getPipelineRun(id: number): Promise<PipelineRun>

type: "file" | "directory"

name: string

children: Map<string, MemoryNode>

content: Buffer<ArrayBufferLike>

stats: MemoryStats

parent: MemoryNode

linkTarget: string

isSymlink: boolean

close(): void