package "fileIo";
import "./@ohos.base";
import "./@ohos.util.stream";
namespace fileIo {

    namespace OpenMode {


    };

};
[Async, Synthetic]
callback AsyncCallback_Boolean_Void = void (boolean result);
[Async, Synthetic]
callback AsyncCallback_Void = void ();
[Async, Synthetic]
callback AsyncCallback_Stream_Void = void (Stream result);
[Async, Synthetic]
callback AsyncCallback_RandomAccessFile_Void = void (RandomAccessFile result);
[Async, Synthetic]
callback AsyncCallback_Array_String_Void = void (sequence<String> result);
[Async, Synthetic]
callback AsyncCallback_Stat_Void = void (Stat result);
[Async, Synthetic]
callback AsyncCallback_String_Void = void (String result);
[Async, Synthetic]
callback AsyncCallback_File_Void = void (File result);
[Async, Synthetic]
callback AsyncCallback_Number_Void = void (number result);
[Async, Synthetic]
callback AsyncCallback_ReaderIterator_Void = void (ReaderIterator result);
[Entity=Interface]
interface Progress {

    readonly attribute number processedSize;
    readonly attribute number totalSize;

};
[Entity=Class]
interface TaskSignal {

    void cancel();
    async String onCancel();

};
[Entity=Interface]
interface CopyOptions {

    [Optional]
    attribute ProgressListener progressListener;
    [Optional]
    attribute TaskSignal copySignal;

};
callback ProgressListener = void (Progress progress);
[Entity=Interface]
interface File {

    readonly attribute number fd;
    readonly attribute String path;
    readonly attribute String name;
    String getParent();
    async void lock(optional boolean exclusive);
    void lock(AsyncCallback_Void callback_);
    void lock(boolean exclusive, AsyncCallback_Void callback_);
    void tryLock(optional boolean exclusive);
    void unlock();

};
[Entity=Interface]
interface RandomAccessFile {

    readonly attribute number fd;
    readonly attribute number filePointer;
    void setFilePointer(number filePointer);
    void close();
    async number write((buffer or String) buffer, optional WriteOptions options);
    void write((buffer or String) buffer, AsyncCallback_Number_Void callback_);
    void write((buffer or String) buffer, WriteOptions options, AsyncCallback_Number_Void callback_);
    number writeSync((buffer or String) buffer, optional WriteOptions options);
    async number read(buffer buffer, optional ReadOptions options);
    void read(buffer buffer, AsyncCallback_Number_Void callback_);
    void read(buffer buffer, ReadOptions options, AsyncCallback_Number_Void callback_);
    number readSync(buffer buffer, optional ReadOptions options);
    ReadStream getReadStream();
    WriteStream getWriteStream();

};
[Entity=Class]
interface ReadStream: stream.Readable {

    constructor();
    readonly attribute number bytesRead;
    readonly attribute String path;
    number seek(number offset, optional WhenceType whence);
    void close();

};
[Entity=Class]
interface WriteStream: stream.Writable {

    constructor();
    readonly attribute number bytesWritten;
    readonly attribute String path;
    number seek(number offset, optional WhenceType whence);
    void close();

};
[Entity=Interface]
interface Stat {

    readonly attribute bigint ino;
    readonly attribute number mode;
    readonly attribute number uid;
    readonly attribute number gid;
    readonly attribute number size;
    readonly attribute number atime;
    readonly attribute number mtime;
    readonly attribute number ctime;
    readonly attribute LocationType location;
    boolean isBlockDevice();
    boolean isCharacterDevice();
    boolean isDirectory();
    boolean isFIFO();
    boolean isFile();
    boolean isSocket();
    boolean isSymbolicLink();

};
[Entity=Interface]
interface Stream {

    async void close();
    void close(AsyncCallback_Void callback_);
    void closeSync();
    async void flush();
    void flush(AsyncCallback_Void callback_);
    void flushSync();
    async number write((buffer or String) buffer, optional WriteOptions options);
    void write((buffer or String) buffer, AsyncCallback_Number_Void callback_);
    void write((buffer or String) buffer, WriteOptions options, AsyncCallback_Number_Void callback_);
    number writeSync((buffer or String) buffer, optional WriteOptions options);
    async number read(buffer buffer, optional ReadOptions options);
    void read(buffer buffer, AsyncCallback_Number_Void callback_);
    void read(buffer buffer, ReadOptions options, AsyncCallback_Number_Void callback_);
    number readSync(buffer buffer, optional ReadOptions options);

};
[Entity=Interface]
interface WatchEventListener {

    [CallSignature]
    void invoke(WatchEvent event);

};
[Entity=Interface]
interface WatchEvent {

    readonly attribute String fileName;
    readonly attribute number event;
    readonly attribute number cookie;

};
[Entity=Interface]
interface Watcher {

    void start();
    void stop();

};
[Entity=Interface]
interface ReaderIteratorResult {

    attribute boolean done;
    attribute String value;

};
[Entity=Interface]
interface ReaderIterator {

    ReaderIteratorResult next();

};
[Entity=Interface]
interface Filter {

    [Optional]
    attribute sequence<String> suffix;
    [Optional]
    attribute sequence<String> displayName;
    [Optional]
    attribute sequence<String> mimeType;
    [Optional]
    attribute number fileSizeOver;
    [Optional]
    attribute number lastModifiedAfter;
    [Optional]
    attribute boolean excludeMedia;

};
[Entity=Interface]
interface ConflictFiles {

    attribute String srcFile;
    attribute String destFile;

};
[Entity=Interface]
interface Options {

    [Optional]
    attribute String encoding;

};
[Entity=Interface]
interface ReadOptions {

    [Optional]
    attribute number offset;
    [Optional]
    attribute number length;

};
[Entity=Interface]
interface ReadTextOptions: ReadOptions {

    [Optional]
    attribute String encoding;

};
[Entity=Interface]
interface WriteOptions: Options {

    [Optional]
    attribute number offset;
    [Optional]
    attribute number length;

};
[Entity=Interface]
interface ListFileOptions {

    [Optional]
    attribute boolean recursion;
    [Optional]
    attribute number listNum;
    [Optional]
    attribute Filter filter;

};
[Entity=Interface]
interface RandomAccessFileOptions {

    [Optional]
    attribute number start;
    [Optional]
    attribute number end;

};
[Entity=Interface]
interface ReadStreamOptions {

    [Optional]
    attribute number start;
    [Optional]
    attribute number end;

};
[Entity=Interface]
interface WriteStreamOptions {

    [Optional]
    attribute number mode;
    [Optional]
    attribute number start;

};
[Entity=Interface]
interface DfsListeners {

    void onStatus(String networkId, number status);

};
dictionary WhenceType {

    number SEEK_SET = 0;
    number SEEK_CUR = 1;
    number SEEK_END = 2;

};
dictionary LocationType {

    number LOCAL = 1;
    number CLOUD = 2;

};
dictionary AccessModeType {

    number EXIST = 0;
    number WRITE = 2;
    number READ = 4;
    number READ_WRITE = 6;

};
dictionary AccessFlagType {

    number LOCAL = 0;

};
[GlobalScope]
interface GlobalScope_ohos_file_fs {

    const number READ_ONLY = 0;
    const number WRITE_ONLY = 1;
    const number READ_WRITE = 2;
    const number CREATE = 64;
    const number TRUNC = 512;
    const number APPEND = 1024;
    const number NONBLOCK = 2048;
    const number DIR = 65536;
    const number NOFOLLOW = 131072;
    const number SYNC = 1052672;
    static async boolean access(String path, optional AccessModeType mode);
    static void access(String path, AsyncCallback_Boolean_Void callback_);
    static async boolean access(String path, AccessModeType mode, AccessFlagType flag);
    static boolean accessSync(String path, optional AccessModeType mode);
    static boolean accessSync(String path, AccessModeType mode, AccessFlagType flag);
    static async void close((number or File) file);
    static void close((number or File) file, AsyncCallback_Void callback_);
    static void closeSync((number or File) file);
    static async void copy(String srcUri, String destUri, optional CopyOptions options);
    static void copy(String srcUri, String destUri, AsyncCallback_Void callback_);
    static void copy(String srcUri, String destUri, CopyOptions options, AsyncCallback_Void callback_);
    static async void copyDir(String src, String dest, optional number mode);
    static void copyDir(String src, String dest, AsyncCallback_Void callback_);
    static void copyDir(String src, String dest, AsyncCallback_Void callback_);
    static void copyDir(String src, String dest, number mode, AsyncCallback_Void callback_);
    static void copyDir(String src, String dest, number mode, AsyncCallback_Void callback_);
    static void copyDirSync(String src, String dest, optional number mode);
    static async void copyFile((String or number) src, (String or number) dest, optional number mode);
    static void copyFile((String or number) src, (String or number) dest, AsyncCallback_Void callback_);
    static void copyFile((String or number) src, (String or number) dest, number mode, AsyncCallback_Void callback_);
    static void copyFileSync((String or number) src, (String or number) dest, optional number mode);
    static async Stream createStream(String path, String mode);
    static void createStream(String path, String mode, AsyncCallback_Stream_Void callback_);
    static Stream createStreamSync(String path, String mode);
    static async RandomAccessFile createRandomAccessFile((String or File) file, optional number mode, optional RandomAccessFileOptions options);
    static void createRandomAccessFile((String or File) file, AsyncCallback_RandomAccessFile_Void callback_);
    static void createRandomAccessFile((String or File) file, number mode, AsyncCallback_RandomAccessFile_Void callback_);
    static RandomAccessFile createRandomAccessFileSync((String or File) file, optional number mode, optional RandomAccessFileOptions options);
    static ReadStream createReadStream(String path, optional ReadStreamOptions options);
    static WriteStream createWriteStream(String path, optional WriteStreamOptions options);
    static Watcher createWatcher(String path, number events, WatchEventListener listener);
    static File dup(number fd);
    static async void fdatasync(number fd);
    static void fdatasync(number fd, AsyncCallback_Void callback_);
    static void fdatasyncSync(number fd);
    static async Stream fdopenStream(number fd, String mode);
    static void fdopenStream(number fd, String mode, AsyncCallback_Stream_Void callback_);
    static Stream fdopenStreamSync(number fd, String mode);
    static async void fsync(number fd);
    static void fsync(number fd, AsyncCallback_Void callback_);
    static void fsyncSync(number fd);
    static async sequence<String> listFile(String path, optional ListFileOptions options);
    static void listFile(String path, AsyncCallback_Array_String_Void callback_);
    static void listFile(String path, ListFileOptions options, AsyncCallback_Array_String_Void callback_);
    static sequence<String> listFileSync(String path, optional ListFileOptions options);
    static number lseek(number fd, number offset, optional WhenceType whence);
    static async Stat lstat(String path);
    static void lstat(String path, AsyncCallback_Stat_Void callback_);
    static Stat lstatSync(String path);
    static async void mkdir(String path);
    static async void mkdir(String path, boolean recursion);
    static void mkdir(String path, AsyncCallback_Void callback_);
    static void mkdir(String path, boolean recursion, AsyncCallback_Void callback_);
    static void mkdirSync(String path);
    static void mkdirSync(String path, boolean recursion);
    static async String mkdtemp(String prefix);
    static void mkdtemp(String prefix, AsyncCallback_String_Void callback_);
    static String mkdtempSync(String prefix);
    static async void moveDir(String src, String dest, optional number mode);
    static void moveDir(String src, String dest, AsyncCallback_Void callback_);
    static void moveDir(String src, String dest, AsyncCallback_Void callback_);
    static void moveDir(String src, String dest, number mode, AsyncCallback_Void callback_);
    static void moveDir(String src, String dest, number mode, AsyncCallback_Void callback_);
    static void moveDirSync(String src, String dest, optional number mode);
    static async void moveFile(String src, String dest, optional number mode);
    static void moveFile(String src, String dest, AsyncCallback_Void callback_);
    static void moveFile(String src, String dest, number mode, AsyncCallback_Void callback_);
    static void moveFileSync(String src, String dest, optional number mode);
    static async File open(String path, optional number mode);
    static void open(String path, AsyncCallback_File_Void callback_);
    static void open(String path, number mode, AsyncCallback_File_Void callback_);
    static File openSync(String path, optional number mode);
    static async number read(number fd, buffer buffer, optional ReadOptions options);
    static void read(number fd, buffer buffer, AsyncCallback_Number_Void callback_);
    static void read(number fd, buffer buffer, ReadOptions options, AsyncCallback_Number_Void callback_);
    static number readSync(number fd, buffer buffer, optional ReadOptions options);
    static async ReaderIterator readLines(String filePath, optional Options options);
    static void readLines(String filePath, AsyncCallback_ReaderIterator_Void callback_);
    static void readLines(String filePath, Options options, AsyncCallback_ReaderIterator_Void callback_);
    static ReaderIterator readLinesSync(String filePath, optional Options options);
    static async String readText(String filePath, optional ReadTextOptions options);
    static void readText(String filePath, AsyncCallback_String_Void callback_);
    static void readText(String filePath, ReadTextOptions options, AsyncCallback_String_Void callback_);
    static String readTextSync(String filePath, optional ReadTextOptions options);
    static async void rename(String oldPath, String newPath);
    static void rename(String oldPath, String newPath, AsyncCallback_Void callback_);
    static void renameSync(String oldPath, String newPath);
    static async void rmdir(String path);
    static void rmdir(String path, AsyncCallback_Void callback_);
    static void rmdirSync(String path);
    static async Stat stat((String or number) file);
    static void stat((String or number) file, AsyncCallback_Stat_Void callback_);
    static Stat statSync((String or number) file);
    static async void symlink(String target, String srcPath);
    static void symlink(String target, String srcPath, AsyncCallback_Void callback_);
    static void symlinkSync(String target, String srcPath);
    static async void truncate((String or number) file, optional number len);
    static void truncate((String or number) file, AsyncCallback_Void callback_);
    static void truncate((String or number) file, number len, AsyncCallback_Void callback_);
    static void truncateSync((String or number) file, optional number len);
    static async void unlink(String path);
    static void unlink(String path, AsyncCallback_Void callback_);
    static void unlinkSync(String path);
    static void utimes(String path, number mtime);
    static async number write(number fd, (buffer or String) buffer, optional WriteOptions options);
    static void write(number fd, (buffer or String) buffer, AsyncCallback_Number_Void callback_);
    static void write(number fd, (buffer or String) buffer, WriteOptions options, AsyncCallback_Number_Void callback_);
    static number writeSync(number fd, (buffer or String) buffer, optional WriteOptions options);
    static async void connectDfs(String networkId, DfsListeners listeners);
    static async void disconnectDfs(String networkId);
    static async void setxattr(String path, String key, String value);
    static void setxattrSync(String path, String key, String value);
    static async String getxattr(String path, String key);
    static String getxattrSync(String path, String key);

};