From f98f90a9a3e58f1d10d7b4d6286122205be334fa Mon Sep 17 00:00:00 2001
From: Ibby Hadeed <ibby93@gmail.com>
Date: Sat, 13 May 2017 22:44:10 -0400
Subject: [PATCH] fix(file): various fixes (#1553)

* save schanges

* save changes

* save changes

* save changes
---
 package.json                            |   1 +
 src/@ionic-native/plugins/file/index.ts | 644 +++++++++++++++---------
 2 files changed, 415 insertions(+), 230 deletions(-)

diff --git a/package.json b/package.json
index ca53196ca6..93f9ff006b 100644
--- a/package.json
+++ b/package.json
@@ -7,6 +7,7 @@
     "@angular/compiler": "4.1.2",
     "@angular/compiler-cli": "4.1.2",
     "@angular/core": "4.1.2",
+    "@types/cordova": "0.0.34",
     "canonical-path": "0.0.2",
     "child-process-promise": "2.2.0",
     "conventional-changelog-cli": "1.2.0",
diff --git a/src/@ionic-native/plugins/file/index.ts b/src/@ionic-native/plugins/file/index.ts
index 5d763a1d14..c0b5d8ba0d 100644
--- a/src/@ionic-native/plugins/file/index.ts
+++ b/src/@ionic-native/plugins/file/index.ts
@@ -1,295 +1,505 @@
 import { Injectable } from '@angular/core';
 import { CordovaProperty, Plugin, CordovaCheck, IonicNativePlugin } from '@ionic-native/core';
 
-declare var window: any;
-declare var cordova: any;
+export interface IFile extends Blob {
+  lastModified: number;
+  lastModifiedDate: number;
+  name: string;
+  size: number;
+  type: string;
+}
+
+export interface LocalFileSystem {
+
+  /**
+   * Used for storage with no guarantee of persistence.
+   */
+  TEMPORARY: number;
+
+  /**
+   * Used for storage that should not be removed by the user agent without application or user permission.
+   */
+  PERSISTENT: number;
+
+  /**
+   * Requests a filesystem in which to store application data.
+   * @param type Whether the filesystem requested should be persistent, as defined above. Use one of TEMPORARY or PERSISTENT.
+   * @param size This is an indicator of how much storage space, in bytes, the application expects to need.
+   * @param successCallback The callback that is called when the user agent provides a filesystem.
+   * @param errorCallback A callback that is called when errors happen, or when the request to obtain the filesystem is denied.
+   */
+  requestFileSystem(type: number, size: number, successCallback: FileSystemCallback, errorCallback?: ErrorCallback): void;
+
+  /**
+   * Allows the user to look up the Entry for a file or directory referred to by a local URL.
+   * @param url A URL referring to a local file in a filesystem accessable via this API.
+   * @param successCallback A callback that is called to report the Entry to which the supplied URL refers.
+   * @param errorCallback A callback that is called when errors happen, or when the request to obtain the Entry is denied.
+   */
+  resolveLocalFileSystemURL(url: string, successCallback: EntryCallback, errorCallback?: ErrorCallback): void;
+
+  /**
+   * see requestFileSystem.
+   */
+  webkitRequestFileSystem(type: number, size: number, successCallback: FileSystemCallback, errorCallback?: ErrorCallback): void;
+}
+
+export interface Metadata {
+  /**
+   * This is the time at which the file or directory was last modified.
+   * @readonly
+   */
+  modificationTime: Date;
+
+  /**
+   * The size of the file, in bytes. This must return 0 for directories.
+   * @readonly
+   */
+  size: number;
+}
 
-/** This interface represents a file system. */
+export interface Flags {
+  /**
+   * Used to indicate that the user wants to create a file or directory if it was not previously there.
+   */
+  create?: boolean;
+
+  /**
+   * By itself, exclusive must have no effect. Used with create, it must cause getFile and getDirectory to fail if the target path already exists.
+   */
+  exclusive?: boolean;
+}
+
+/**
+ * This export interface represents a file system.
+ */
 export interface FileSystem {
-  /* The name of the file system, unique across the list of exposed file systems. */
+  /**
+   * This is the name of the file system. The specifics of naming filesystems is unspecified, but a name must be unique across the list of exposed file systems.
+   * @readonly
+   */
   name: string;
-  /** The root directory of the file system. */
+
+  /**
+   * The root directory of the file system.
+   * @readonly
+   */
   root: DirectoryEntry;
 }
 
-/**
- * An abstract interface representing entries in a file system,
- * each of which may be a File or DirectoryEntry.
- */
 export interface Entry {
-  /** Entry is a file. */
+
+  /**
+   * Entry is a file.
+   */
   isFile: boolean;
-  /** Entry is a directory. */
+
+  /**
+   * Entry is a directory.
+   */
   isDirectory: boolean;
-  /** The name of the entry, excluding the path leading to it. */
-  name: string;
-  /** The full absolute path from the root to the entry. */
-  fullPath: string;
-  /** The file system on which the entry resides. */
-  filesystem: FileSystem;
-  nativeURL: string;
+
   /**
    * Look up metadata about this entry.
    * @param successCallback A callback that is called with the time of the last modification.
-   * @param errorCallback   A callback that is called when errors happen.
+   * @param errorCallback ErrorCallback A callback that is called when errors happen.
+   */
+  getMetadata(successCallback: MetadataCallback, errorCallback?: ErrorCallback): void;
+
+  /**
+   * The name of the entry, excluding the path leading to it.
+   */
+  name: string;
+
+  /**
+   * The full absolute path from the root to the entry.
    */
-  getMetadata(successCallback: (metadata: Metadata) => void,
-    errorCallback?: (error: FileError) => void): void;
+  fullPath: string;
+
+  /**
+   * The file system on which the entry resides.
+   */
+  filesystem: FileSystem;
+
   /**
    * Move an entry to a different location on the file system. It is an error to try to:
-   *     move a directory inside itself or to any child at any depth;move an entry into its parent if a name different from its current one isn't provided;
-   *     move a file to a path occupied by a directory;
-   *     move a directory to a path occupied by a file;
-   *     move any element to a path occupied by a directory which is not empty.
+   *
+   * <ui>
+   * <li>move a directory inside itself or to any child at any depth;</li>
+   * <li>move an entry into its parent if a name different from its current one isn't provided;</li>
+   * <li>move a file to a path occupied by a directory;</li>
+   * <li>move a directory to a path occupied by a file;</li>
+   * <li>move any element to a path occupied by a directory which is not empty.</li>
+   * <ul>
+   *
    * A move of a file on top of an existing file must attempt to delete and replace that file.
    * A move of a directory on top of an existing empty directory must attempt to delete and replace that directory.
-   * @param parent  The directory to which to move the entry.
-   * @param newName The new name of the entry. Defaults to the Entry's current name if unspecified.
-   * @param successCallback A callback that is called with the Entry for the new location.
-   * @param errorCallback   A callback that is called when errors happen.
    */
-  moveTo(parent: DirectoryEntry,
-    newName?: string,
-    successCallback?: (entry: Entry) => void,
-    errorCallback?: (error: FileError) => void): void;
+  moveTo(parent: DirectoryEntry, newName?: string, successCallback?: EntryCallback, errorCallback?: ErrorCallback): void;
+
   /**
    * Copy an entry to a different location on the file system. It is an error to try to:
-   *     copy a directory inside itself or to any child at any depth;
-   *     copy an entry into its parent if a name different from its current one isn't provided;
-   *     copy a file to a path occupied by a directory;
-   *     copy a directory to a path occupied by a file;
-   *     copy any element to a path occupied by a directory which is not empty.
-   *     A copy of a file on top of an existing file must attempt to delete and replace that file.
-   *     A copy of a directory on top of an existing empty directory must attempt to delete and replace that directory.
+   *
+   * <ul>
+   * <li> copy a directory inside itself or to any child at any depth;</li>
+   * <li> copy an entry into its parent if a name different from its current one isn't provided;</li>
+   * <li> copy a file to a path occupied by a directory;</li>
+   * <li> copy a directory to a path occupied by a file;</li>
+   * <li> copy any element to a path occupied by a directory which is not empty.</li>
+   * <li> A copy of a file on top of an existing file must attempt to delete and replace that file.</li>
+   * <li> A copy of a directory on top of an existing empty directory must attempt to delete and replace that directory.</li>
+   * </ul>
+   *
    * Directory copies are always recursive--that is, they copy all contents of the directory.
-   * @param parent The directory to which to move the entry.
-   * @param newName The new name of the entry. Defaults to the Entry's current name if unspecified.
-   * @param successCallback A callback that is called with the Entry for the new object.
-   * @param errorCallback A callback that is called when errors happen.
    */
-  copyTo(parent: DirectoryEntry,
-    newName?: string,
-    successCallback?: (entry: Entry) => void,
-    errorCallback?: (error: FileError) => void): void;
+  copyTo(parent: DirectoryEntry, newName?: string, successCallback?: EntryCallback, errorCallback?: ErrorCallback): void;
+
   /**
-   * Returns a URL that can be used as the src attribute of a <video> or <audio> tag.
-   * If that is not possible, construct a cdvfile:// URL.
-   * @return string URL
+   * Returns a URL that can be used to identify this entry. Unlike the URN defined in [FILE-API-ED], it has no specific expiration; as it describes a location on disk, it should be valid at least as long as that location exists.
    */
   toURL(): string;
-  /**
-   * Return a URL that can be passed across the bridge to identify this entry.
-   * @return string URL that can be passed across the bridge to identify this entry
-   */
-  toInternalURL(): string;
+
   /**
    * Deletes a file or directory. It is an error to attempt to delete a directory that is not empty. It is an error to attempt to delete the root directory of a filesystem.
    * @param successCallback A callback that is called on success.
-   * @param errorCallback   A callback that is called when errors happen.
+   * @param errorCallback A callback that is called when errors happen.
    */
-  remove(successCallback: () => void,
-    errorCallback?: (error: FileError) => void): void;
+  remove(successCallback: VoidCallback, errorCallback?: ErrorCallback): void;
+
   /**
    * Look up the parent DirectoryEntry containing this Entry. If this Entry is the root of its filesystem, its parent is itself.
-   * @param successCallback A callback that is called with the time of the last modification.
-   * @param errorCallback   A callback that is called when errors happen.
+   * @param successCallback A callback that is called to return the parent Entry.
+   * @param errorCallback A callback that is called when errors happen.
    */
-  getParent(successCallback: (entry: Entry) => void,
-    errorCallback?: (error: FileError) => void): void;
-}
-
-/** This interface supplies information about the state of a file or directory. */
-export interface Metadata {
-  /** This is the time at which the file or directory was last modified. */
-  modificationTime: Date;
-  /** The size of the file, in bytes. This must return 0 for directories. */
-  size: number;
+  getParent(successCallback: DirectoryEntryCallback, errorCallback?: ErrorCallback): void;
 }
 
-/** This interface represents a directory on a file system. */
+/**
+ * This export interface represents a directory on a file system.
+ */
 export interface DirectoryEntry extends Entry {
   /**
    * Creates a new DirectoryReader to read Entries from this Directory.
    */
   createReader(): DirectoryReader;
+
   /**
    * Creates or looks up a file.
-   * @param path    Either an absolute path or a relative path from this DirectoryEntry
-   *                to the file to be looked up or created.
-   *                It is an error to attempt to create a file whose immediate parent does not yet exist.
-   * @param options If create and exclusive are both true, and the path already exists, getFile must fail.
-   *                If create is true, the path doesn't exist, and no other error occurs, getFile must create it as a zero-length file and return a corresponding FileEntry.
-   *                If create is not true and the path doesn't exist, getFile must fail.
-   *                If create is not true and the path exists, but is a directory, getFile must fail.
-   *                Otherwise, if no other error occurs, getFile must return a FileEntry corresponding to path.
+   * @param path Either an absolute path or a relative path from this DirectoryEntry to the file to be looked up or created. It is an error to attempt to create a file whose immediate parent does not yet exist.
+   * @param options
+   *     <ul>
+   *     <li>If create and exclusive are both true, and the path already exists, getFile must fail.</li>
+   *     <li>If create is true, the path doesn't exist, and no other error occurs, getFile must create it as a zero-length file and return a corresponding FileEntry.</li>
+   *     <li>If create is not true and the path doesn't exist, getFile must fail.</li>
+   *     <li>If create is not true and the path exists, but is a directory, getFile must fail.</li>
+   *     <li>Otherwise, if no other error occurs, getFile must return a FileEntry corresponding to path.</li>
+   *     </ul>
    * @param successCallback A callback that is called to return the File selected or created.
-   * @param errorCallback   A callback that is called when errors happen.
+   * @param errorCallback A callback that is called when errors happen.
    */
-  getFile(path: string, options?: Flags,
-    successCallback?: (entry: FileEntry) => void,
-    errorCallback?: (error: FileError) => void): void;
+  getFile(path: string, options?: Flags, successCallback?: FileEntryCallback, errorCallback?: ErrorCallback): void;
+
   /**
    * Creates or looks up a directory.
-   * @param path    Either an absolute path or a relative path from this DirectoryEntry
-   *                to the directory to be looked up or created.
-   *                It is an error to attempt to create a directory whose immediate parent does not yet exist.
-   * @param options If create and exclusive are both true and the path already exists, getDirectory must fail.
-   *                If create is true, the path doesn't exist, and no other error occurs, getDirectory must create and return a corresponding DirectoryEntry.
-   *                If create is not true and the path doesn't exist, getDirectory must fail.
-   *                If create is not true and the path exists, but is a file, getDirectory must fail.
-   *                Otherwise, if no other error occurs, getDirectory must return a DirectoryEntry corresponding to path.
-   * @param successCallback A callback that is called to return the Directory selected or created.
-   * @param errorCallback   A callback that is called when errors happen.
-   */
-  getDirectory(path: string, options?: Flags,
-    successCallback?: (entry: DirectoryEntry) => void,
-    errorCallback?: (error: FileError) => void): void;
-  /**
-   * Deletes a directory and all of its contents, if any. In the event of an error (e.g. trying
-   * to delete a directory that contains a file that cannot be removed), some of the contents
-   * of the directory may be deleted. It is an error to attempt to delete the root directory of a filesystem.
+   * @param path Either an absolute path or a relative path from this DirectoryEntry to the directory to be looked up or created. It is an error to attempt to create a directory whose immediate parent does not yet exist.
+   * @param options
+   *     <ul>
+   *     <li>If create and exclusive are both true and the path already exists, getDirectory must fail.</li>
+   *     <li>If create is true, the path doesn't exist, and no other error occurs, getDirectory must create and return a corresponding DirectoryEntry.</li>
+   *     <li>If create is not true and the path doesn't exist, getDirectory must fail.</li>
+   *     <li>If create is not true and the path exists, but is a file, getDirectory must fail.</li>
+   *     <li>Otherwise, if no other error occurs, getDirectory must return a DirectoryEntry corresponding to path.</li>
+   *     </ul>
+   * @param successCallback   A callback that is called to return the DirectoryEntry selected or created.
+   * @param errorCallback A callback that is called when errors happen.
+   *
+   */
+  getDirectory(path: string, options?: Flags, successCallback?: DirectoryEntryCallback, errorCallback?: ErrorCallback): void;
+
+  /**
+   * Deletes a directory and all of its contents, if any. In the event of an error [e.g. trying to delete a directory that contains a file that cannot be removed], some of the contents of the directory may be deleted. It is an error to attempt to delete the root directory of a filesystem.
    * @param successCallback A callback that is called on success.
-   * @param errorCallback   A callback that is called when errors happen.
+   * @param errorCallback A callback that is called when errors happen.
    */
-  removeRecursively(successCallback: () => void,
-    errorCallback?: (error: FileError) => void): void;
+  removeRecursively(successCallback: VoidCallback, errorCallback?: ErrorCallback): void;
 }
 
-export interface RemoveResult {
-  success: boolean;
-  fileRemoved: Entry;
+/**
+ * This export interface lets a user list files and directories in a directory. If there are no additions to or deletions from a directory between the first and last call to readEntries, and no errors occur, then:
+ * <ul>
+ * <li> A series of calls to readEntries must return each entry in the directory exactly once.</li>
+ * <li> Once all entries have been returned, the next call to readEntries must produce an empty array.</li>
+ * <li> If not all entries have been returned, the array produced by readEntries must not be empty.</li>
+ * <li> The entries produced by readEntries must not include the directory itself ["."] or its parent [".."].</li>
+ * </ul>
+ */
+export interface DirectoryReader {
+  /**
+   * Read the next block of entries from this directory.
+   * @param successCallback Called once per successful call to readEntries to deliver the next previously-unreported set of Entries in the associated Directory. If all Entries have already been returned from previous invocations of readEntries, successCallback must be called with a zero-length array as an argument.
+   * @param errorCallback A callback indicating that there was an error reading from the Directory.
+   */
+  readEntries(successCallback: EntriesCallback, errorCallback?: ErrorCallback): void;
 }
 
 /**
- * This dictionary is used to supply arguments to methods
- * that look up or create files or directories.
+ * This export interface represents a file on a file system.
  */
-export interface Flags {
-  /** Used to indicate that the user wants to create a file or directory if it was not previously there. */
-  create?: boolean;
-  /** By itself, exclusive must have no effect. Used with create, it must cause getFile and getDirectory to fail if the target path already exists. */
-  exclusive?: boolean;
+export interface FileEntry extends Entry {
+  /**
+   * Creates a new FileWriter associated with the file that this FileEntry represents.
+   * @param successCallback A callback that is called with the new FileWriter.
+   * @param errorCallback A callback that is called when errors happen.
+   */
+  createWriter(successCallback: FileWriterCallback, errorCallback?: ErrorCallback): void;
+
+  /**
+   * Returns a File that represents the current state of the file that this FileEntry represents.
+   * @param successCallback A callback that is called with the File.
+   * @param errorCallback A callback that is called when errors happen.
+   */
+  file(successCallback: FileCallback, errorCallback?: ErrorCallback): void;
 }
 
-export interface WriteOptions {
-  replace?: boolean;
-  append?: boolean;
-  truncate?: number; // if present, number of bytes to truncate file to before writing
+/**
+ * When requestFileSystem() succeeds, the following callback is made.
+ */
+export interface FileSystemCallback {
+  /**
+   * @param filesystem The file systems to which the app is granted access.
+   */
+  (filesystem: FileSystem): void;
 }
 
 /**
- * This interface lets a user list files and directories in a directory. If there are
- * no additions to or deletions from a directory between the first and last call to
- * readEntries, and no errors occur, then:
- *     A series of calls to readEntries must return each entry in the directory exactly once.
- *     Once all entries have been returned, the next call to readEntries must produce an empty array.
- *     If not all entries have been returned, the array produced by readEntries must not be empty.
- *     The entries produced by readEntries must not include the directory itself ["."] or its parent [".."].
+ * This export interface is the callback used to look up Entry objects.
  */
-export interface DirectoryReader {
+export interface EntryCallback {
   /**
-   * Read the next block of entries from this directory.
-   * @param successCallback Called once per successful call to readEntries to deliver the next
-   *                        previously-unreported set of Entries in the associated Directory.
-   *                        If all Entries have already been returned from previous invocations
-   *                        of readEntries, successCallback must be called with a zero-length array as an argument.
-   * @param errorCallback   A callback indicating that there was an error reading from the Directory.
-   */
-  readEntries(successCallback: (entries: Entry[]) => void,
-    errorCallback?: (error: FileError) => void): void;
+   * @param entry
+   */
+  (entry: Entry): void;
 }
 
-/** This interface represents a file on a file system. */
-export interface FileEntry extends Entry {
+/**
+ * This export interface is the callback used to look up FileEntry objects.
+ */
+export interface FileEntryCallback {
   /**
-   * Creates a new FileWriter associated with the file that this FileEntry represents.
-   * @param successCallback A callback that is called with the new FileWriter.
-   * @param errorCallback   A callback that is called when errors happen.
+   * @param entry
    */
-  createWriter(successCallback: (writer: FileWriter) => void,
-    errorCallback?: (error: FileError) => void): void;
+  (entry: FileEntry): void;
+}
+
+/**
+ * This export interface is the callback used to look up DirectoryEntry objects.
+ */
+export interface DirectoryEntryCallback {
   /**
-   * Returns a File that represents the current state of the file that this FileEntry represents.
-   * @param successCallback A callback that is called with the File.
-   * @param errorCallback   A callback that is called when errors happen.
+   * @param entry
    */
-  file(successCallback: (file: File) => void,
-    errorCallback?: (error: FileError) => void): void;
+  (entry: DirectoryEntry): void;
+}
+
+/**
+ * When readEntries() succeeds, the following callback is made.
+ */
+export interface EntriesCallback {
+  (entries: Entry[]): void;
+}
+
+/**
+ * This export interface is the callback used to look up file and directory metadata.
+ */
+export interface MetadataCallback {
+  (metadata: Metadata): void;
+}
+
+/**
+ * This export interface is the callback used to create a FileWriter.
+ */
+export interface FileWriterCallback {
+  (fileWriter: FileWriter): void;
+}
+
+/**
+ * This export interface is the callback used to obtain a File.
+ */
+export interface FileCallback {
+  (file: IFile): void;
+}
+
+/**
+ * This export interface is the generic callback used to indicate success of an asynchronous method.
+ */
+export interface VoidCallback {
+  (): void;
 }
 
 /**
- * This interface provides methods to monitor the asynchronous writing of blobs
- * to disk using progress events and event handler attributes.
+ * When an error occurs, the following callback is made.
  */
-export interface FileSaver extends EventTarget {
-  /** Terminate file operation */
+export interface ErrorCallback {
+  (err: FileError): void;
+}
+
+export interface RemoveResult {
+  success: boolean;
+  fileRemoved: Entry;
+}
+
+export declare class FileSaver extends EventTarget {
+  /**
+   * When the FileSaver constructor is called, the user agent must return a new FileSaver object with readyState set to INIT.
+   * This constructor must be visible when the script's global object is either a Window object or an object implementing the WorkerUtils interface.
+   */
+  constructor(data: Blob);
+
+  /**
+   * When the abort method is called, user agents must run the steps below:
+   * <ol>
+   * <li> If readyState == DONE or readyState == INIT, terminate this overall series of steps without doing anything else. </li>
+   * <li> Set readyState to DONE. </li>
+   * <li> If there are any tasks from the object's FileSaver task source in one of the task queues, then remove those tasks. </li>
+   * <li> Terminate the write algorithm being processed. </li>
+   * <li> Set the error attribute to a DOMError object of type "AbortError". </li>
+   * <li> Fire a progress event called abort </li>
+   * <li> Fire a progress event called writeend </li>
+   * <li> Terminate this algorithm. </li>
+   * </ol>
+   */
   abort(): void;
+
   /**
-   * The FileSaver object can be in one of 3 states. The readyState attribute, on getting,
-   * must return the current state, which must be one of the following values:
-   *     INIT
-   *     WRITING
-   *     DONE
+   * The blob is being written.
+   * @readonly
+   */
+  INIT: number;
+
+  /**
+   * The object has been constructed, but there is no pending write.
+   * @readonly
+   */
+  WRITING: number;
+
+  /**
+   * The entire Blob has been written to the file, an error occurred during the write, or the write was aborted using abort(). The FileSaver is no longer writing the blob.
+   * @readonly
+   */
+  DONE: number;
+
+  /**
+   * The FileSaver object can be in one of 3 states. The readyState attribute, on getting, must return the current state, which must be one of the following values:
+   * <ul>
+   * <li>INIT</li>
+   * <li>WRITING</li>
+   * <li>DONE</li>
+   * <ul>
+   * @readonly
    */
   readyState: number;
-  /** Handler for writestart events. */
+
+  /**
+   * The last error that occurred on the FileSaver.
+   * @readonly
+   */
+  error: Error;
+
+  /**
+   * Handler for writestart events
+   */
   onwritestart: (event: ProgressEvent) => void;
-  /** Handler for progress events. */
+
+  /**
+   * Handler for progress events.
+   */
   onprogress: (event: ProgressEvent) => void;
-  /** Handler for write events. */
+
+  /**
+   * Handler for write events.
+   */
   onwrite: (event: ProgressEvent) => void;
-  /** Handler for abort events. */
+
+  /**
+   * Handler for abort events.
+   */
   onabort: (event: ProgressEvent) => void;
-  /** Handler for error events. */
+
+  /**
+   * Handler for error events.
+   */
   onerror: (event: ProgressEvent) => void;
-  /** Handler for writeend events. */
+
+  /**
+   * Handler for writeend events.
+   */
   onwriteend: (event: ProgressEvent) => void;
-  /** The last error that occurred on the FileSaver. */
-  error: Error;
 }
 
 /**
- * This interface expands on the FileSaver interface to allow for multiple write
- * actions, rather than just saving a single Blob.
+ * This interface expands on the FileSaver interface to allow for multiple write actions, rather than just saving a single Blob.
  */
-export interface FileWriter extends FileSaver {
+export declare class FileWriter extends FileSaver {
   /**
-   * The byte offset at which the next write to the file will occur. This always less or equal than length.
-   * A newly-created FileWriter will have position set to 0.
+   * The byte offset at which the next write to the file will occur. This must be no greater than length.
+   * A newly-created FileWriter must have position set to 0.
    */
   position: number;
+
   /**
-   * The length of the file. If the user does not have read access to the file,
-   * this will be the highest byte offset at which the user has written.
+   * The length of the file. If the user does not have read access to the file, this must be the highest byte offset at which the user has written.
    */
   length: number;
+
   /**
    * Write the supplied data to the file at position.
-   * @param {Blob} data The blob to write.
+   * @param data The blob to write.
    */
   write(data: ArrayBuffer | Blob | string): void;
+
   /**
-   * The file position at which the next write will occur.
-   * @param offset If nonnegative, an absolute byte offset into the file.
-   *               If negative, an offset back from the end of the file.
+   * Seek sets the file position at which the next write will occur.
+   * @param offset If nonnegative, an absolute byte offset into the file. If negative, an offset back from the end of the file.
    */
   seek(offset: number): void;
+
   /**
-   * Changes the length of the file to that specified. If shortening the file, data beyond the new length
-   * will be discarded. If extending the file, the existing data will be zero-padded up to the new length.
+   * Changes the length of the file to that specified. If shortening the file, data beyond the new length must be discarded. If extending the file, the existing data must be zero-padded up to the new length.
    * @param size The size to which the length of the file is to be adjusted, measured in bytes.
    */
   truncate(size: number): void;
 }
 
-/* FileWriter states */
-export declare var FileWriter: {
-  INIT: number;
-  WRITING: number;
-  DONE: number
-};
+export interface IWriteOptions {
+  replace?: boolean;
+  append?: boolean;
+  truncate?: number; // if present, number of bytes to truncate file to before writing
+}
+
+export declare class FileError {
+  constructor(code: number);
+  static NOT_FOUND_ERR: number;
+  static SECURITY_ERR: number;
+  static ABORT_ERR: number;
+  static NOT_READABLE_ERR: number;
+  static ENCODING_ERR: number;
+  static NO_MODIFICATION_ALLOWED_ERR: number;
+  static INVALID_STATE_ERR: number;
+  static SYNTAX_ERR: number;
+  static INVALID_MODIFICATION_ERR: number;
+  static QUOTA_EXCEEDED_ERR: number;
+  static TYPE_MISMATCH_ERR: number;
+  static PATH_EXISTS_ERR: number;
+  /** Error code */
+  code: number;
+  message: string;
+}
+
+export declare class FileReader {
+  static EMPTY: number;
+  static LOADING: number;
+  static DONE: number;
 
-export interface FileReader {
   readyState: number; // see constants in var declaration below
   error: Error;
   result: string | ArrayBuffer; // type depends on readAsXXX() call type
@@ -302,42 +512,16 @@ export interface FileReader {
   onabort: (evt: ProgressEvent) => void;
 
   abort(): void;
-  readAsText(fe: File | Blob, encoding?: string): void;
-  readAsDataURL(fe: File | Blob): void;
-  readAsBinaryString(fe: File | Blob): void;
-  readAsArrayBuffer(fe: File | Blob): void;
-}
+  readAsText(fe: IFile, encoding?: string): void;
+  readAsDataURL(fe: IFile): void;
+  readAsBinaryString(fe: IFile): void;
+  readAsArrayBuffer(fe: IFile): void;
 
-export declare var FileReader: {
-  EMPTY: number;
-  LOADING: number;
-  DONE: number;
-
-  new (): FileReader;
-};
-
-export interface FileError {
-  /** Error code */
-  code: number;
-  message: string;
 }
 
-export declare var FileError: {
-  new (code: number): FileError;
-  NOT_FOUND_ERR: number;
-  SECURITY_ERR: number;
-  ABORT_ERR: number;
-  NOT_READABLE_ERR: number;
-  ENCODING_ERR: number;
-  NO_MODIFICATION_ALLOWED_ERR: number;
-  INVALID_STATE_ERR: number;
-  SYNTAX_ERR: number;
-  INVALID_MODIFICATION_ERR: number;
-  QUOTA_EXCEEDED_ERR: number;
-  TYPE_MISMATCH_ERR: number;
-  PATH_EXISTS_ERR: number;
-};
+interface Window extends LocalFileSystem {}
 
+declare const window: Window;
 
 /**
  * @name File
@@ -358,16 +542,16 @@ export declare var FileError: {
  *
  * ```
  *
- *  This plugin is based on several specs, including : The HTML5 File API http://www.w3.org/TR/FileAPI/
- *  The (now-defunct) Directories and System extensions Latest: http://www.w3.org/TR/2012/WD-file-system-api-20120417/
- *  Although most of the plugin code was written when an earlier spec was current: http://www.w3.org/TR/2011/WD-file-system-api-20110419/
- *  It also implements the FileWriter spec : http://dev.w3.org/2009/dap/file-system/file-writer.html
+ *  This plugin is based on several specs, including : The HTML5 File API http: //www.w3.org/TR/FileAPI/
+ *  The (now-defunct) Directories and System extensions Latest: http: //www.w3.org/TR/2012/WD-file-system-api-20120417/
+ *  Although most of the plugin code was written when an earlier spec was current: http: //www.w3.org/TR/2011/WD-file-system-api-20110419/
+ *  It also implements the FileWriter spec : http: //dev.w3.org/2009/dap/file-system/file-writer.html
  */
 @Plugin({
   pluginName: 'File',
   plugin: 'cordova-plugin-file',
   pluginRef: 'cordova.file',
-  repo: 'https://github.com/apache/cordova-plugin-file',
+  repo: 'https: //github.com/apache/cordova-plugin-file',
   platforms: ['Android', 'BlackBerry 10', 'Browser', 'Firefox OS', 'iOS', 'OS X', 'Ubuntu', 'Windows', 'Windows Phone']
 })
 @Injectable()
@@ -749,12 +933,12 @@ export class File extends IonicNativePlugin {
    * @param {string} path Base FileSystem. Please refer to the iOS and Android filesystems above
    * @param {string} fileName path relative to base path
    * @param {string | Blob} text content or blob to write
-   * @param {WriteOptions} options replace file if set to true. See WriteOptions for more information.
+   * @param {IWriteOptions} options replace file if set to true. See WriteOptions for more information.
    * @returns {Promise<any>} Returns a Promise that resolves to updated file entry or rejects with an error.
    */
   @CordovaCheck()
   writeFile(path: string, fileName: string,
-    text: string | Blob | ArrayBuffer, options: WriteOptions = {}): Promise<any> {
+            text: string | Blob | ArrayBuffer, options: IWriteOptions = {}): Promise<any> {
     if ((/^\//.test(fileName))) {
       const err = new FileError(5);
       err.message = 'file-name cannot start with \/';
@@ -780,10 +964,10 @@ export class File extends IonicNativePlugin {
    * @hidden
    * @param {FileEntry} fe file entry object
    * @param {string | Blob} text content or blob to write
-   * @param {WriteOptions} options replace file if set to true. See WriteOptions for more information.
+   * @param {IWriteOptions} options replace file if set to true. See WriteOptions for more information.
    * @returns {Promise<FileEntry>} Returns a Promise that resolves to updated file entry or rejects with an error.
    */
-  private writeFileEntry(fe: FileEntry, text: string | Blob | ArrayBuffer, options: WriteOptions) {
+  private writeFileEntry(fe: FileEntry, text: string | Blob | ArrayBuffer, options: IWriteOptions) {
     return this.createWriter(fe)
       .then((writer) => {
         if (options.append) {
@@ -827,7 +1011,7 @@ export class File extends IonicNativePlugin {
   /**
    * Read file and return data as a base64 encoded data url.
    * A data url is of the form:
-   *      data:[<mediatype>][;base64],<data>
+   *      data: [<mediatype>][;base64],<data>
 
    * @param {string} path Base FileSystem. Please refer to the iOS and Android filesystems above
    * @param {string} file Name of file, relative to path.
@@ -872,7 +1056,7 @@ export class File extends IonicNativePlugin {
         return this.getFile(directoryEntry, file, { create: false });
       })
       .then((fileEntry: FileEntry) => {
-        let reader = new FileReader();
+        const reader = new FileReader();
         return new Promise<T>((resolve, reject) => {
           reader.onloadend = () => {
             if (reader.result !== undefined || reader.result !== null) {
@@ -974,7 +1158,7 @@ export class File extends IonicNativePlugin {
   resolveLocalFilesystemUrl(fileUrl: string): Promise<Entry> {
     return new Promise<Entry>((resolve, reject) => {
       try {
-        window.resolveLocalFileSystemURL(fileUrl, (entry) => {
+        window.resolveLocalFileSystemURL(fileUrl, (entry: Entry) => {
           resolve(entry);
         }, (err) => {
           this.fillErrorMessage(err);
@@ -999,7 +1183,7 @@ export class File extends IonicNativePlugin {
         if (de.isDirectory) {
           return <DirectoryEntry>de;
         } else {
-          let err = new FileError(13);
+          const err = new FileError(13);
           err.message = 'input is not a directory';
           return Promise.reject<DirectoryEntry>(err);
         }