@types/fs-extra-promise

  • Version 1.0.13
  • Published
  • 7.55 kB
  • 3 dependencies
  • MIT license

Install

npm i @types/fs-extra-promise
yarn add @types/fs-extra-promise
pnpm add @types/fs-extra-promise

Overview

TypeScript definitions for fs-extra-promise

Index

Functions

function appendFileAsync

appendFileAsync: (
filename: string,
data: any,
option?: string | WriteOptions
) => Promise<void>;

    function chmodAsync

    chmodAsync: (path: string, mode: number | string) => Promise<void>;

      function chownAsync

      chownAsync: (path: string, uid: number, gid: number) => Promise<void>;

        function closeAsync

        closeAsync: (fd: number) => Promise<void>;

          function copyAsync

          copyAsync: (
          src: string,
          dest: string,
          options?: CopyFilter | CopyOptions
          ) => Promise<void>;

            function createFileAsync

            createFileAsync: (file: string) => Promise<void>;

              function ensureDirAsync

              ensureDirAsync: (path: string) => Promise<void>;

                function existsAsync

                existsAsync: (path: string) => Promise<boolean>;

                  function fchmodAsync

                  fchmodAsync: (fd: number, mode: number | string) => Promise<void>;

                    function fchownAsync

                    fchownAsync: (fd: number, uid: number, gid: number) => Promise<void>;

                      function fstatAsync

                      fstatAsync: (fd: number) => Promise<Stats>;

                        function fsyncAsync

                        fsyncAsync: (fd: number) => Promise<void>;

                          function futimesAsync

                          futimesAsync: (fd: number, atime: number, mtime: number) => Promise<void>;

                            function isDirectory

                            isDirectory: (
                            path: string,
                            callback?: (err: Error, isDirectory: boolean) => void
                            ) => void;

                              function isDirectoryAsync

                              isDirectoryAsync: (path: string) => Promise<boolean>;

                                function isDirectorySync

                                isDirectorySync: (path: string) => boolean;

                                  function lchmodAsync

                                  lchmodAsync: (path: string, mode: number | string) => Promise<void>;

                                    function lchownAsync

                                    lchownAsync: (path: string, uid: number, gid: number) => Promise<void>;

                                      function linkAsync

                                      linkAsync: (srcpath: string, dstpath: string) => Promise<void>;

                                        function lstatAsync

                                        lstatAsync: (path: string) => Promise<Stats>;

                                          function mkdirAsync

                                          mkdirAsync: (path: string, mode?: number | string) => Promise<void>;

                                            function mkdirpAsync

                                            mkdirpAsync: (dir: string, options?: MkdirOptions) => Promise<void>;

                                              function mkdirsAsync

                                              mkdirsAsync: (dir: string, options?: MkdirOptions) => Promise<void>;

                                                function mkdtempAsync

                                                mkdtempAsync: (
                                                prefix: string,
                                                options: string | { encoding: string }
                                                ) => Promise<string>;

                                                  function moveAsync

                                                  moveAsync: (src: string, dest: string, options?: MoveOptions) => Promise<void>;

                                                    function openAsync

                                                    openAsync: (path: string, flags: string, mode?: string) => Promise<number>;

                                                      function outputFileAsync

                                                      outputFileAsync: (file: string, data: any) => Promise<void>;

                                                        function outputJsonAsync

                                                        outputJsonAsync: (file: string, data: any) => Promise<void>;

                                                          function outputJSONAsync

                                                          outputJSONAsync: (file: string, data: any) => Promise<void>;

                                                            function readAsync

                                                            readAsync: (
                                                            fd: number,
                                                            buffer: Buffer,
                                                            offset: number,
                                                            length: number,
                                                            position: number
                                                            ) => Promise<[number, Buffer]>;

                                                              function readdirAsync

                                                              readdirAsync: (path: string) => Promise<string[]>;

                                                                function readFileAsync

                                                                readFileAsync: {
                                                                (filename: string, options: string | ReadOptions): Promise<string>;
                                                                (filename: string): Promise<Buffer>;
                                                                };

                                                                  function readJsonAsync

                                                                  readJsonAsync: (file: string, options?: ReadOptions) => Promise<any>;

                                                                    function readJSONAsync

                                                                    readJSONAsync: (file: string, options?: ReadOptions) => Promise<any>;

                                                                      function readlinkAsync

                                                                      readlinkAsync: (path: string) => Promise<string>;

                                                                        function realpathAsync

                                                                        realpathAsync: (
                                                                        path: string,
                                                                        cache?: { [path: string]: string }
                                                                        ) => Promise<string>;

                                                                          function removeAsync

                                                                          removeAsync: (dir: string) => Promise<void>;

                                                                            function renameAsync

                                                                            renameAsync: (oldPath: string, newPath: string) => Promise<void>;

                                                                              function rmdirAsync

                                                                              rmdirAsync: (path: string) => Promise<void>;

                                                                                function statAsync

                                                                                statAsync: (path: string) => Promise<Stats>;

                                                                                  function symlinkAsync

                                                                                  symlinkAsync: (
                                                                                  srcpath: string,
                                                                                  dstpath: string,
                                                                                  type?: fs.symlink.Type
                                                                                  ) => Promise<void>;

                                                                                    function truncateAsync

                                                                                    truncateAsync: (fd: number, len: number) => Promise<void>;

                                                                                      function unlinkAsync

                                                                                      unlinkAsync: (path: string) => Promise<void>;

                                                                                        function utimesAsync

                                                                                        utimesAsync: (path: string, atime: number, mtime: number) => Promise<void>;

                                                                                          function writeAsync

                                                                                          writeAsync: (
                                                                                          fd: number,
                                                                                          buffer: Buffer,
                                                                                          offset: number,
                                                                                          length: number,
                                                                                          position: number
                                                                                          ) => Promise<[number, Buffer]>;

                                                                                            function writeFileAsync

                                                                                            writeFileAsync: (
                                                                                            filename: string,
                                                                                            data: any,
                                                                                            options?: string | WriteOptions
                                                                                            ) => Promise<void>;

                                                                                              function writeJsonAsync

                                                                                              writeJsonAsync: (
                                                                                              file: string,
                                                                                              object: any,
                                                                                              options?: WriteOptions
                                                                                              ) => Promise<void>;

                                                                                                function writeJSONAsync

                                                                                                writeJSONAsync: (
                                                                                                file: string,
                                                                                                object: any,
                                                                                                options?: WriteOptions
                                                                                                ) => Promise<void>;

                                                                                                  Interfaces

                                                                                                  interface MkdirOptions

                                                                                                  interface MkdirOptions {}

                                                                                                    property fs

                                                                                                    fs?: any;

                                                                                                      property mode

                                                                                                      mode?: number | undefined;

                                                                                                        Package Files (1)

                                                                                                        Dependencies (3)

                                                                                                        Dev Dependencies (0)

                                                                                                        No dev dependencies.

                                                                                                        Peer Dependencies (0)

                                                                                                        No peer dependencies.

                                                                                                        Badge

                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/fs-extra-promise.

                                                                                                        • Markdown
                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/fs-extra-promise)
                                                                                                        • HTML
                                                                                                          <a href="https://www.jsdocs.io/package/@types/fs-extra-promise"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>