SFTP

export declare function decodeSFTPCopyDataExtension(data: Buffer): Readonly<SFTPCopyDataExtension>;

export declare function decodeSFTPExtensionString(data: Buffer): Buffer;

export declare function decodeSFTPHandleExtension(data: Buffer): Buffer;

export declare function decodeSFTPLimits(data: Buffer): Readonly<SFTPLimits>;

export declare function decodeSFTPLSetStatExtension(data: Buffer): Readonly<SFTPLSetStatExtension>;

export declare function decodeSFTPPacket(frame: Buffer): SFTPPacket;

export declare function decodeSFTPStatVFS(data: Buffer): Readonly<SFTPStatVFS>;

export declare function decodeSFTPTwoPathExtension(data: Buffer): Readonly<SFTPTwoPathExtension>;

export declare function decodeSFTPUsersGroups(data: Buffer): Readonly<SFTPUserGroupNames>;

export declare function decodeSFTPUsersGroupsExtension(data: Buffer): Readonly<SFTPUsersGroupsExtension>;

export declare function encodeSFTPAttributes(attributes: SFTPAttributes): Buffer;

export declare function encodeSFTPCopyDataExtension(sourceHandle: Buffer, sourceOffset: bigint, length: bigint, destinationHandle: Buffer, destinationOffset: bigint): Buffer;

export declare function encodeSFTPExtensionString(value: Buffer | string): Buffer;

export declare function encodeSFTPLimits(limits: Readonly<SFTPLimits>): Buffer;

export declare function encodeSFTPLSetStatExtension(path: Buffer, attributes: SFTPAttributes): Buffer;

export declare function encodeSFTPPacket(packet: SFTPPacket): Buffer;

export declare function encodeSFTPStatVFS(statistics: Readonly<SFTPStatVFS>): Buffer;

export declare function encodeSFTPTwoPathExtension(firstPath: Buffer, secondPath: Buffer): Buffer;

export declare function encodeSFTPUsersGroups(names: Readonly<SFTPUserGroupNames>): Buffer;

export declare function encodeSFTPUsersGroupsExtension(uids: readonly number[], gids: readonly number[]): Buffer;

export declare function flagsToString(flags: number): string | null;

export declare const MAX_SFTP_HANDLE_LENGTH = 256;

export declare const MAX_SFTP_PACKET_LENGTH: number;

export declare const OPEN_MODE: Readonly<{
    READ: SFTPOpenFlags.Read;
    WRITE: SFTPOpenFlags.Write;
    APPEND: SFTPOpenFlags.Append;
    CREAT: SFTPOpenFlags.Create;
    TRUNC: SFTPOpenFlags.Truncate;
    EXCL: SFTPOpenFlags.Exclusive;
}>;

export declare const SFTP_VERSION = 3;

export declare enum SFTPAttributeFlags {
    Size = 1,
    UIDGID = 2,
    Permissions = 4,
    AccessModificationTime = 8,
    Extended = 2147483648
}

export interface SFTPAttributes {
    size?: bigint;
    uid?: number;
    gid?: number;
    permissions?: number;
    accessTime?: number;
    modificationTime?: number;
    extended?: readonly SFTPExtendedAttribute[];
}

export interface SFTPAttrsPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Attrs;
    attributes: SFTPAttributes;
}

export default class SFTPClient extends EventEmitter<SFTPClientEvents> {
    readonly protocolVersion = 3;
    readonly channel: ClientSessionChannel;
    readonly isOpenSSH: boolean;
    readonly requestTimeout: number;
    maxReadLength: number;
    maxWriteLength: number;
    maxOpenHandles: number | undefined;
    limits: Readonly<SFTPLimits> | undefined;
    static connect(channel: ClientSessionChannel, isOpenSSH?: boolean, options?: SFTPClientOptions): Promise<SFTPClient>;
    get extensions(): readonly SFTPExtension[];
    supportsExtension(name: string, version?: string): boolean;
    extended(name: string, data?: Buffer, options?: SFTPExtendedRequestOptions): Promise<SFTPExtensionResponsePacket>;
    createReadStream(path: SFTPPath, options?: SFTPReadStreamOptions): SFTPReadStream;
    createWriteStream(path: SFTPPath, options?: SFTPWriteStreamOptions): SFTPWriteStream;
    exists(path: SFTPPath): Promise<boolean>;
    readFile(path: SFTPPath): Promise<Buffer>;
    readFile(path: SFTPPath, encoding: BufferEncoding): Promise<string>;
    readFile(path: SFTPPath, options: SFTPReadFileOptions & {
        encoding: BufferEncoding;
    }): Promise<string>;
    readFile(path: SFTPPath, options?: SFTPReadFileOptions): Promise<Buffer>;
    writeFile(path: SFTPPath, data: string | Buffer, options?: BufferEncoding | SFTPWriteFileOptions): Promise<void>;
    appendFile(path: SFTPPath, data: string | Buffer, options?: BufferEncoding | SFTPWriteFileOptions): Promise<void>;
    fastGet(remotePath: SFTPPath, localPath: string, options?: SFTPFastGetOptions): Promise<void>;
    fastPut(localPath: string, remotePath: SFTPPath, options?: SFTPFastPutOptions): Promise<void>;
    open(path: SFTPPath, flags: string | number, attributes?: SFTPAttributes): Promise<Buffer>;
    /** Close the SFTP session and settle after its SSH channel closes. */
    close(): Promise<void>;
    /** Close one active remote file, directory, or extension handle. */
    close(handle: Buffer): Promise<void>;
    read(handle: Buffer, length: number, position: SFTPPosition): Promise<Buffer>;
    read(handle: Buffer, buffer: Buffer, bufferOffset: number, length: number, position: SFTPPosition): Promise<SFTPReadResult>;
    write(handle: Buffer, data: Buffer, position: SFTPPosition): Promise<void>;
    write(handle: Buffer, buffer: Buffer, bufferOffset: number, length: number, position: SFTPPosition): Promise<SFTPWriteResult>;
    stat(path: SFTPPath): Promise<SFTPStats>;
    lstat(path: SFTPPath): Promise<SFTPStats>;
    fstat(handle: Buffer): Promise<SFTPStats>;
    setstat(path: SFTPPath, attributes: SFTPAttributes): Promise<void>;
    fsetstat(handle: Buffer, attributes: SFTPAttributes): Promise<void>;
    truncate(path: SFTPPath, length: SFTPPosition): Promise<void>;
    ftruncate(handle: Buffer, length: SFTPPosition): Promise<void>;
    opendir(path: SFTPPath): Promise<Buffer>;
    readdir(handle: Buffer): Promise<readonly SFTPClientNameEntry[] | null>;
    iterateDirectory(path: SFTPPath): AsyncGenerator<SFTPClientNameEntry, void, void>;
    readDirectory(path: SFTPPath, options?: SFTPReadDirectoryOptions): Promise<readonly SFTPClientNameEntry[]>;
    unlink(path: SFTPPath): Promise<void>;
    remove(path: SFTPPath): Promise<void>;
    mkdir(path: SFTPPath, attributes?: SFTPAttributes): Promise<void>;
    rmdir(path: SFTPPath): Promise<void>;
    rename(oldPath: SFTPPath, newPath: SFTPPath): Promise<void>;
    realpath(path: SFTPPath, encoding: "buffer"): Promise<Buffer>;
    realpath(path: SFTPPath, encoding?: "utf8"): Promise<string>;
    readlink(path: SFTPPath, encoding: "buffer"): Promise<Buffer>;
    readlink(path: SFTPPath, encoding?: "utf8"): Promise<string>;
    symlink(targetPath: SFTPPath, linkPath: SFTPPath): Promise<void>;
    opensshPosixRename(oldPath: SFTPPath, newPath: SFTPPath): Promise<void>;
    ext_openssh_rename(oldPath: SFTPPath, newPath: SFTPPath): Promise<void>;
    opensshStatVFS(path: SFTPPath): Promise<Readonly<SFTPStatVFS>>;
    ext_openssh_statvfs(path: SFTPPath): Promise<Readonly<SFTPStatVFS>>;
    opensshFStatVFS(handle: Buffer): Promise<Readonly<SFTPStatVFS>>;
    ext_openssh_fstatvfs(handle: Buffer): Promise<Readonly<SFTPStatVFS>>;
    opensshHardlink(oldPath: SFTPPath, newPath: SFTPPath): Promise<void>;
    ext_openssh_hardlink(oldPath: SFTPPath, newPath: SFTPPath): Promise<void>;
    opensshFSync(handle: Buffer): Promise<void>;
    ext_openssh_fsync(handle: Buffer): Promise<void>;
    opensshLSetStat(path: SFTPPath, attributes: SFTPAttributes): Promise<void>;
    ext_openssh_lsetstat(path: SFTPPath, attributes: SFTPAttributes): Promise<void>;
    opensshExpandPath(path: SFTPPath, encoding: "buffer"): Promise<Buffer>;
    opensshExpandPath(path: SFTPPath, encoding?: "utf8"): Promise<string>;
    ext_openssh_expandPath(path: SFTPPath, encoding: "buffer"): Promise<Buffer>;
    ext_openssh_expandPath(path: SFTPPath, encoding?: "utf8"): Promise<string>;
    copyData(sourceHandle: Buffer, sourceOffset: SFTPPosition, length: SFTPPosition, destinationHandle: Buffer, destinationOffset: SFTPPosition): Promise<void>;
    ext_copy_data(sourceHandle: Buffer, sourceOffset: SFTPPosition, length: SFTPPosition, destinationHandle: Buffer, destinationOffset: SFTPPosition): Promise<void>;
    homeDirectory(username: string | Buffer, encoding: "buffer"): Promise<Buffer>;
    homeDirectory(username?: string | Buffer, encoding?: "utf8"): Promise<string>;
    ext_home_dir(username: string | Buffer, encoding: "buffer"): Promise<Buffer>;
    ext_home_dir(username?: string | Buffer, encoding?: "utf8"): Promise<string>;
    usersGroups(uids: readonly number[], gids: readonly number[]): Promise<Readonly<SFTPUserGroupNames>>;
    ext_users_groups(uids: readonly number[], gids: readonly number[]): Promise<Readonly<SFTPUserGroupNames>>;
    opensshLimits(): Promise<Readonly<SFTPLimits>>;
    chmod(path: SFTPPath, mode: number | string): Promise<void>;
    fchmod(handle: Buffer, mode: number | string): Promise<void>;
    chown(path: SFTPPath, uid: number, gid: number): Promise<void>;
    fchown(handle: Buffer, uid: number, gid: number): Promise<void>;
    utimes(path: SFTPPath, accessTime: Date | number, modificationTime: Date | number): Promise<void>;
    futimes(handle: Buffer, accessTime: Date | number, modificationTime: Date | number): Promise<void>;
    end(): void;
    [Symbol.asyncDispose](): Promise<void>;
    destroy(error?: Error): void;
}

export interface SFTPClientEvents {
    downloadProgress: [
        progress: SFTPTransferProgress
    ];
    uploadProgress: [
        progress: SFTPTransferProgress
    ];
}

export interface SFTPClientNameEntry extends Omit<SFTPNameEntry, "attributes"> {
    attributes: SFTPStats;
}

export interface SFTPClientOptions {
    /** Maximum integer milliseconds for initialization or a reply. Range: 1 through 2147483647. */
    requestTimeout?: number;
}

export interface SFTPCopyDataExtension {
    sourceHandle: Buffer;
    sourceOffset: bigint;
    length: bigint;
    destinationHandle: Buffer;
    destinationOffset: bigint;
}

export interface SFTPDataPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Data;
    data: Buffer;
}

export interface SFTPExtendedAttribute {
    readonly type: Buffer;
    readonly data: Buffer;
}

export interface SFTPExtendedPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Extended;
    request: string;
    data: Buffer;
}

export interface SFTPExtendedReplyPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.ExtendedReply;
    data: Buffer;
}

export interface SFTPExtendedRequestOptions {
    /** Require this exact advertised extension version. */
    version?: string;
    /** Successful packet types accepted for this extension. Defaults to EXTENDED_REPLY. */
    expectedTypes?: readonly SFTPExtensionResponseType[];
}

export interface SFTPExtension {
    readonly name: string;
    readonly data: Buffer;
}

export type SFTPExtensionResponsePacket = SFTPStatusPacket | SFTPHandlePacket | SFTPDataPacket | SFTPNamePacket | SFTPAttrsPacket | SFTPExtendedReplyPacket;

export type SFTPExtensionResponseType = SFTPExtensionResponsePacket["type"];

export interface SFTPFastGetOptions {
    chunkSize?: number;
    concurrency?: number;
}

export interface SFTPFastPutOptions extends SFTPFastGetOptions {
    mode?: number | string;
}

export interface SFTPFSetStatPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.FSetStat;
    handle: Buffer;
    attributes: SFTPAttributes;
}

export interface SFTPHandlePacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Handle;
    handle: Buffer;
}

export interface SFTPHandleRequestPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Close | SFTPPacketType.FStat | SFTPPacketType.ReadDir;
    handle: Buffer;
}

export interface SFTPInitPacket {
    type: SFTPPacketType.Init;
    version: number;
    extensions: readonly SFTPExtension[];
}

export interface SFTPLimits {
    maximumPacketLength: bigint;
    maximumReadLength: bigint;
    maximumWriteLength: bigint;
    maximumOpenHandles: bigint;
}

export interface SFTPLSetStatExtension {
    path: Buffer;
    attributes: Readonly<SFTPAttributes>;
}

export interface SFTPMkDirPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.MkDir;
    path: Buffer;
    attributes: SFTPAttributes;
}

export type SFTPNameEncoding = "utf8" | "buffer";

export interface SFTPNameEntry {
    filename: Buffer;
    longname: Buffer;
    attributes: SFTPAttributes;
}

export interface SFTPNamePacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Name;
    names: readonly SFTPNameEntry[];
}

export declare function sftpOpenFlags(flags: string | number): number;

export declare enum SFTPOpenFlags {
    Read = 1,
    Write = 2,
    Append = 4,
    Create = 8,
    Truncate = 16,
    Exclusive = 32
}

export interface SFTPOpenPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Open;
    filename: Buffer;
    flags: number;
    attributes: SFTPAttributes;
}

export type SFTPPacket = SFTPInitPacket | SFTPVersionPacket | SFTPOpenPacket | SFTPHandleRequestPacket | SFTPReadPacket | SFTPWritePacket | SFTPPathPacket | SFTPSetStatPacket | SFTPFSetStatPacket | SFTPMkDirPacket | SFTPTwoPathPacket | SFTPStatusPacket | SFTPHandlePacket | SFTPDataPacket | SFTPNamePacket | SFTPAttrsPacket | SFTPExtendedPacket | SFTPExtendedReplyPacket;

export declare class SFTPPacketParser {
    push(chunk: Buffer): SFTPPacket[];
    end(): void;
}

export declare enum SFTPPacketType {
    Init = 1,
    Version = 2,
    Open = 3,
    Close = 4,
    Read = 5,
    Write = 6,
    LStat = 7,
    FStat = 8,
    SetStat = 9,
    FSetStat = 10,
    OpenDir = 11,
    ReadDir = 12,
    Remove = 13,
    MkDir = 14,
    RmDir = 15,
    RealPath = 16,
    Stat = 17,
    Rename = 18,
    ReadLink = 19,
    SymLink = 20,
    Status = 101,
    Handle = 102,
    Data = 103,
    Name = 104,
    Attrs = 105,
    Extended = 200,
    ExtendedReply = 201
}

export type SFTPPath = string | Buffer;

export interface SFTPPathPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.LStat | SFTPPacketType.OpenDir | SFTPPacketType.Remove | SFTPPacketType.RmDir | SFTPPacketType.RealPath | SFTPPacketType.Stat | SFTPPacketType.ReadLink;
    path: Buffer;
}

export type SFTPPosition = number | bigint;

export declare class SFTPProtocolError extends Error {
    constructor(message: string);
}

export interface SFTPReadDirectoryOptions {
    /** Maximum non-dot entries retained by readDirectory. Defaults to 100,000. */
    maxEntries?: number;
    /** Maximum bytes retained in entry names and extended attributes. Defaults to 16 MiB. */
    maxBytes?: number;
}

export interface SFTPReadFileOptions {
    encoding?: BufferEncoding | null;
    flag?: string | number;
    maxBytes?: number;
}

export interface SFTPReadPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Read;
    handle: Buffer;
    offset: bigint;
    length: number;
}

export interface SFTPReadResult {
    bytesRead: number;
    buffer: Buffer;
}

export declare class SFTPReadStream extends Readable {
    readonly sftp: SFTPClient;
    readonly flags: string | number;
    readonly mode: number;
    readonly autoClose: boolean;
    readonly start: bigint;
    readonly end: bigint;
    bytesRead: bigint;
    isClosed: boolean;
    constructor(sftp: SFTPClient, path: SFTPPath, options?: SFTPReadStreamOptions);
    get path(): SFTPPath;
    get handle(): Buffer | undefined;
    get pending(): boolean;
    close(): Promise<void>;
    _read(size: number): void;
    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
}

export interface SFTPReadStreamOptions extends ReadableOptions {
    autoClose?: boolean;
    end?: SFTPPosition;
    flags?: string | number;
    handle?: Buffer;
    mode?: number | string;
    start?: SFTPPosition;
}

export type SFTPRequestOf<T extends SFTPPacketType> = Readonly<SFTPRequestPacket & {
    type: T;
}>;

export type SFTPRequestPacket = SFTPOpenPacket | SFTPHandleRequestPacket | SFTPReadPacket | SFTPWritePacket | SFTPPathPacket | SFTPSetStatPacket | SFTPFSetStatPacket | SFTPMkDirPacket | SFTPTwoPathPacket | SFTPExtendedPacket;

export interface SFTPRequestPacketBase {
    requestId: number;
}

export default class SFTPServer extends EventEmitter<SFTPServerEvents> {
    readonly hooker: Hooker<SFTPServerHooker>;
    readonly protocolVersion = 3;
    readonly stream: Shell;
    readonly openSSHSymlinkArguments: boolean;
    constructor(stream: Shell, options?: SFTPServerOptions);
    get maxConcurrentRequests(): number;
    get maxOutstandingRequestBytes(): number;
    get maxOpenHandles(): number;
    get maxReadLength(): number;
    get maxWriteLength(): number;
    get extensions(): readonly SFTPExtension[];
    status(requestId: number, code: SFTPStatusCode, message?: string, languageTag?: string): Promise<void>;
    handle(requestId: number, handle: Buffer): Promise<void>;
    data(requestId: number, data: Buffer): Promise<void>;
    name(requestId: number, names: SFTPNameEntry | readonly SFTPNameEntry[]): Promise<void>;
    attributes(requestId: number, attributes: SFTPAttributes): Promise<void>;
    extendedReply(requestId: number, data: Buffer): Promise<void>;
    symlinkPaths(request: SFTPRequestOf<SFTPPacketType.SymLink>): Readonly<SFTPSymlinkPaths>;
    destroy(error?: Error): void;
    /** Close the subsystem and settle after its SSH channel closes. */
    close(): Promise<void>;
    [Symbol.asyncDispose](): Promise<void>;
}

export type SFTPServerEvents = {
    ready: [
        clientVersion: number
    ];
    close: [
    ];
    error: [
        error: Error
    ];
    requestReceived: [
        request: Readonly<SFTPRequestPacket>
    ];
};

export type SFTPServerHooker = {
    request: [
        request: Readonly<SFTPRequestPacket>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    OPEN: [
        request: SFTPRequestOf<SFTPPacketType.Open>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    CLOSE: [
        request: SFTPRequestOf<SFTPPacketType.Close>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    READ: [
        request: SFTPRequestOf<SFTPPacketType.Read>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    WRITE: [
        request: SFTPRequestOf<SFTPPacketType.Write>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    LSTAT: [
        request: SFTPRequestOf<SFTPPacketType.LStat>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    FSTAT: [
        request: SFTPRequestOf<SFTPPacketType.FStat>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    SETSTAT: [
        request: SFTPRequestOf<SFTPPacketType.SetStat>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    FSETSTAT: [
        request: SFTPRequestOf<SFTPPacketType.FSetStat>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    OPENDIR: [
        request: SFTPRequestOf<SFTPPacketType.OpenDir>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    READDIR: [
        request: SFTPRequestOf<SFTPPacketType.ReadDir>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    REMOVE: [
        request: SFTPRequestOf<SFTPPacketType.Remove>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    MKDIR: [
        request: SFTPRequestOf<SFTPPacketType.MkDir>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    RMDIR: [
        request: SFTPRequestOf<SFTPPacketType.RmDir>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    REALPATH: [
        request: SFTPRequestOf<SFTPPacketType.RealPath>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    STAT: [
        request: SFTPRequestOf<SFTPPacketType.Stat>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    RENAME: [
        request: SFTPRequestOf<SFTPPacketType.Rename>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    READLINK: [
        request: SFTPRequestOf<SFTPPacketType.ReadLink>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    SYMLINK: [
        request: SFTPRequestOf<SFTPPacketType.SymLink>,
        operation: Readonly<SFTPServerOperationContext>
    ];
    EXTENDED: [
        request: SFTPRequestOf<SFTPPacketType.Extended>,
        operation: Readonly<SFTPServerOperationContext>
    ];
};

export interface SFTPServerOperationContext {
    /** Aborted when this request expires or its SFTP channel closes. */
    readonly signal: AbortSignal;
}

export interface SFTPServerOptions {
    extensions?: readonly SFTPExtension[];
    openSSHSymlinkArguments?: boolean;
    /** Maximum request hooks allowed to run concurrently. */
    maxConcurrentRequests?: number;
    /** Maximum decoded wire bytes retained by active and queued requests. */
    maxOutstandingRequestBytes?: number;
    /** Maximum active and pending baseline file or directory handles. */
    maxOpenHandles?: number;
    /** Largest READ length passed to application policy. */
    maxReadLength?: number;
    /** Largest WRITE data field passed to application policy. */
    maxWriteLength?: number;
    /** Advertise and answer the limits extension. Defaults to true when handles are enabled. */
    advertiseLimits?: boolean;
    /** Integer milliseconds to wait for close. Defaults to 30000; range: 1 through 2147483647. */
    closeTimeout?: number;
    /**
     * Integer milliseconds for initialization, policy, and response writes.
     * Defaults to 30000; range: 1 through 2147483647.
     */
    requestTimeout?: number;
}

export interface SFTPSetStatPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.SetStat;
    path: Buffer;
    attributes: SFTPAttributes;
}

export declare class SFTPStats implements SFTPAttributes {
    readonly size: bigint | undefined;
    readonly uid: number | undefined;
    readonly gid: number | undefined;
    readonly permissions: number | undefined;
    readonly accessTime: number | undefined;
    readonly modificationTime: number | undefined;
    readonly extended: readonly SFTPExtendedAttribute[] | undefined;
    constructor(attributes?: SFTPAttributes);
    get mode(): number | undefined;
    get atime(): number | undefined;
    get mtime(): number | undefined;
    isDirectory(): boolean;
    isFile(): boolean;
    isBlockDevice(): boolean;
    isCharacterDevice(): boolean;
    isSymbolicLink(): boolean;
    isFIFO(): boolean;
    isSocket(): boolean;
}

export declare enum SFTPStatusCode {
    Ok = 0,
    EOF = 1,
    NoSuchFile = 2,
    PermissionDenied = 3,
    Failure = 4,
    BadMessage = 5,
    NoConnection = 6,
    ConnectionLost = 7,
    OperationUnsupported = 8,
    /** Registered extension status used by copy-data version 1. */
    InvalidParameter = 23
}

export declare class SFTPStatusError extends Error {
    readonly code: number;
    readonly requestId: number;
    readonly languageTag: string;
    constructor(packet: SFTPStatusPacket);
}

export interface SFTPStatusPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Status;
    code: number;
    message: string;
    languageTag: string;
}

export interface SFTPStatVFS {
    blockSize: bigint;
    fragmentSize: bigint;
    blocks: bigint;
    blocksFree: bigint;
    blocksAvailable: bigint;
    files: bigint;
    filesFree: bigint;
    filesAvailable: bigint;
    filesystemId: bigint;
    flags: bigint;
    maximumFilenameLength: bigint;
}

export interface SFTPSymlinkPaths {
    targetPath: Buffer;
    linkPath: Buffer;
}

export interface SFTPTransferProgress {
    readonly remotePath: Buffer;
    readonly localPath: string;
    readonly transferred: number;
    readonly chunk: number;
    readonly total: number;
}

export interface SFTPTwoPathExtension {
    firstPath: Buffer;
    secondPath: Buffer;
}

export interface SFTPTwoPathPacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Rename | SFTPPacketType.SymLink;
    firstPath: Buffer;
    secondPath: Buffer;
}

export interface SFTPUserGroupNames {
    usernames: readonly string[];
    groupNames: readonly string[];
}

export interface SFTPUsersGroupsExtension {
    uids: readonly number[];
    gids: readonly number[];
}

export interface SFTPVersionPacket {
    type: SFTPPacketType.Version;
    version: number;
    extensions: readonly SFTPExtension[];
}

export interface SFTPWriteFileOptions {
    encoding?: BufferEncoding;
    flag?: string | number;
    mode?: number | string;
}

export interface SFTPWritePacket extends SFTPRequestPacketBase {
    type: SFTPPacketType.Write;
    handle: Buffer;
    offset: bigint;
    data: Buffer;
}

export interface SFTPWriteResult {
    bytesWritten: number;
    buffer: Buffer;
}

export declare class SFTPWriteStream extends Writable {
    readonly sftp: SFTPClient;
    readonly flags: string | number;
    readonly mode: number;
    readonly autoClose: boolean;
    readonly start: bigint;
    bytesWritten: bigint;
    isClosed: boolean;
    constructor(sftp: SFTPClient, path: SFTPPath, options?: SFTPWriteStreamOptions);
    get path(): SFTPPath;
    get handle(): Buffer | undefined;
    get pending(): boolean;
    close(): Promise<void>;
    destroySoon(): this;
    _write(chunk: Buffer | string, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
}

export interface SFTPWriteStreamOptions extends WritableOptions {
    autoClose?: boolean;
    flags?: string | number;
    handle?: Buffer;
    mode?: number | string;
    start?: SFTPPosition;
}

export declare class SFTPStats implements SFTPAttributes {
    readonly size: bigint | undefined;
    readonly uid: number | undefined;
    readonly gid: number | undefined;
    readonly permissions: number | undefined;
    readonly accessTime: number | undefined;
    readonly modificationTime: number | undefined;
    readonly extended: readonly SFTPExtendedAttribute[] | undefined;
    constructor(attributes?: SFTPAttributes);
    get mode(): number | undefined;
    get atime(): number | undefined;
    get mtime(): number | undefined;
    isDirectory(): boolean;
    isFile(): boolean;
    isBlockDevice(): boolean;
    isCharacterDevice(): boolean;
    isSymbolicLink(): boolean;
    isFIFO(): boolean;
    isSocket(): boolean;
}

export declare const STATUS_CODE: Readonly<{
    OK: SFTPStatusCode.Ok;
    EOF: SFTPStatusCode.EOF;
    NO_SUCH_FILE: SFTPStatusCode.NoSuchFile;
    PERMISSION_DENIED: SFTPStatusCode.PermissionDenied;
    FAILURE: SFTPStatusCode.Failure;
    BAD_MESSAGE: SFTPStatusCode.BadMessage;
    NO_CONNECTION: SFTPStatusCode.NoConnection;
    CONNECTION_LOST: SFTPStatusCode.ConnectionLost;
    OP_UNSUPPORTED: SFTPStatusCode.OperationUnsupported;
    INVALID_PARAMETER: SFTPStatusCode.InvalidParameter;
}>;

export declare function stringToFlags(flags: string): number | null;