path: root/chromium/chrome/common/extensions/api/file_manager_private.idl

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// fileManagerPrivate API.
// This is a private API used by the file manager on ChromeOS. The API can
// roughly be divided into two parts: functions and events.
//
// Functions: The Functions interface defines a number of privileged operations
// that allow File Manager to execute tasks not available via public APIs. Most
// of the time this is due to the fact that enabling those tasks via public APIs
// would allow malicious applications to either take control of the hardware
// or leak private information about the user. None of these API must be exposed
// in any public services.
//
// Events: The Event interface defines a number of events that are supported
// by the API. These events allow one to register, in JavaScript, a listener
// that is invoked with event's parameters, every time the event is observed
// by the file_manager::EventRouter.
//
// Both the functions and events interface are only available to clients that
// are explicitly granted permission to use the fileManagerPrivate API. This
// API is not available to any client without code reviewed changes
// (eg. via _api_features.json)
//
// CAVEAT: An application A registering as a listener to any events must assume
// that an application B can listen to any events that are destined for A, where
// A and B are any applications that are granted access to fileManagerPrivate.
// For example, if applications A and B listen to onDirectoryChanged events on
// two unique paths, they both receive events about changes in either path. This
// is due to the fact that events are broadcasted to ALL listeners. It is the
// responsibility of the listener to discard events not destined for it. It is
// also the responsibility of all listeners not to log information transmitted
// in those events, as it may record in logs information that is private to a
// given user (e.g., the full paths and name of a given file).  This API is
// designed with the assumption that all users are equal in terms of their
// permission to observe events, call the function interface and access the file
// system of the device. As the API is only used by Chrome OS' File Manager, and
// the File Manager is being used by the user to access their own files, this
// assumption holds true.
//
// The API defined in this file may use W3C Entry object (FileEntry and
// DirectoryEntry). Since these cannot be directly sent or received by the C++
// code, there exists an additional layer, in file_manager_private_internal.idl,
// that provides translation from or to W3C Entry objects.
[platforms=("chromeos"),
 implemented_in="chrome/browser/chromeos/extensions/file_manager/file_manager_private_api_functions.h"]
namespace fileManagerPrivate {
// Type of the mounted volume.
enum VolumeType { drive, downloads, removable, archive, provided, mtp,
                  media_view, crostini, android_files, documents_provider,
                  testing, smb, system_internal };

// Device type. Available if this is removable volume.
enum DeviceType { usb, sd, optical, mobile, unknown };

// List of connection types of drive.
enum DriveConnectionStateType {OFFLINE, METERED, ONLINE};

// List of reasons of DriveConnectionStateType.
enum DriveOfflineReason {NOT_READY, NO_NETWORK, NO_SERVICE};

// Additional data about mount, for example, that the filesystem is not
// supported.
enum MountCondition { unknown, unsupported };

// Additional information of the context the volume was mounted.
enum MountContext { user, auto };

// Is the event raised for mounting or unmounting.
enum MountCompletedEventType { mount, unmount };

// Event type that tells listeners if mount was successful or an error
// occurred. It also specifies the error.
enum MountCompletedStatus {
  success,
  error_unknown,
  error_internal,
  error_invalid_argument,
  error_invalid_path,
  error_path_already_mounted,
  error_path_not_mounted,
  error_directory_creation_failed,
  error_invalid_mount_options,
  error_invalid_unmount_options,
  error_insufficient_permissions,
  error_mount_program_not_found,
  error_mount_program_failed,
  error_invalid_device_path,
  error_unknown_filesystem,
  error_unsupported_filesystem,
  error_invalid_archive,
  error_need_password
};

// Filesystem to format to.
enum FormatFileSystemType { vfat, exfat, ntfs };

// File transfer progress state.
enum TransferState { in_progress, completed, failed };

// The type of the progress event for copy or move operations.
// A copy or a cross-filesystem move happens recursively: these events are
// expected for each single entry (file or directory) being moved.
// A local (same-filesystem) move only requires the top-level entries to be
// renamed: if we move entries 'a.txt', 'b/c.txt', 'b/d.txt' (relative paths),
// events will be received for only for 'a.txt' and 'b'.
enum CopyOrMoveProgressStatusType {
  // "begin" is fired for each entry (file or directory) before
  // starting the copy or move operation.
  begin,

  // "progress" is fired periodically to report progress of a file copy or move
  // (not directory).
  progress,

  // "end_copy" is fired for each entry (file or directory) that has been
  // successfully copied to its destination. This event is expected both both
  // copies and cross-filesystem moves (implemented as copy + delete).
  end_copy,

  // "end_move" is fired for each entry (file or directory) that has been
  // successfully moved to its destination, in the case of a "same-filesystem"
  // move.
  end_move,

  // "end_remove_source" is fired for each entry (file or directory) that has
  // been successfully removed from its source location as part of a
  // "cross-filesystem" move operation.
  end_remove_source,

  // "success" is fired after all entries have been copied or moved.
  success,

  // "error" is fired when an error occurs.
  error
};

// The response when starting installing a Linux package.
enum InstallLinuxPackageResponse {
  started,
  failed,
  install_already_active
};

// Specifies type of event that is raised.
enum FileWatchEventType { changed, error };

// Specifies type of change in file watch event.
enum ChangeType { add_or_update, delete };

// The type of entry that is needed. Default to ALL.
enum SearchType { EXCLUDE_DIRECTORIES, SHARED_WITH_ME, OFFLINE, ALL };

// Zooming mode.
enum ZoomOperationType { in, out, reset };

// Specifies how to open inspector.
enum InspectionType {
  // Open inspector for foreground page.
  normal,
  // Open inspector for foreground page and bring focus to the console.
  console,
  // Open inspector for foreground page in inspect element mode.
  element,
  // Open inspector for background page.
  background
};

// Device event type.
enum DeviceEventType {
  // If the device is disabled by preference.
  disabled,
  // Device is removed.
  removed,
  // Device is hard unplugged.
  hard_unplugged,
  // Format started.
  format_start,
  // Format succeeded.
  format_success,
  // Format failed.
  format_fail,
  // Rename started.
  rename_start,
  // Rename succeeded.
  rename_success,
  // Rename failed.
  rename_fail,
  // Partition started.
  partition_start,
  // Partition succeeded.
  partition_success,
  // Partition failed.
  partition_fail
};

// Drive sync error type.
// Keep it synced with DriveError::Type in drivefs.mojom.
enum DriveSyncErrorType {
  // Request to delete a file without permission.
  delete_without_permission,
  // Google Drive is temporarily unavailable.
  service_unavailable,
  // There is no server space to sync a file.
  no_server_space,
  // There is no local space to sync a file.
  no_local_space,
  // Miscellaneous errors other than listed above.
  misc
};

// Drive confirm dialog type.
// Keep it synced with DialogReason::Type in drivefs.mojom.
enum DriveConfirmDialogType {
  // Request to enable Docs Offline to allow saving hosted files offline.
  enable_docs_offline
};

// Possible result of dialog displayed as a result of the onDriveConfirmDialog
// event. Sent back to the browser via notifyDriveDialogResult().
enum DriveDialogResult {
  // The dialog was not displayed to the user.
  not_displayed,
  // The user accepted the action proposed by the dialog.
  accept,
  // The user rejected the action proposed by the dialog.
  reject,
  // The user closed the dialog without selecting an option.
  dismiss
};

// Result of task execution. If changing, update the strings used in
// ui/file_manager/file_manager/foreground/js/file_tasks.js
enum TaskResult {
  // The task execution succeeded and a new window/tab was opened on the current
  // desktop.
  opened,
  // The task execution succeeded and the message was sent to the proper
  // extension or app. This could result in a window being opened on a different
  // desktop.
  message_sent,
  // The task execution failed.
  failed,
  // No URL is specified.
  empty,
  // The task was a |plugin_vm| task, and the file was in an unshared directory
  failed_plugin_vm_directory_not_shared
};

// Drive share type.
enum DriveShareType {
  can_edit,
  can_comment,
  can_view
};

// Names of properties for getEntryProperties().
enum EntryPropertyName {
  size,
  modificationTime,
  modificationByMeTime,
  thumbnailUrl,
  croppedThumbnailUrl,
  imageWidth,
  imageHeight,
  imageRotation,
  pinned,
  present,
  hosted,
  availableOffline,
  availableWhenMetered,
  dirty,
  customIconUrl,
  contentMimeType,
  sharedWithMe,
  shared,
  starred,
  externalFileUrl,
  alternateUrl,
  shareUrl,
  canCopy,
  canDelete,
  canRename,
  canAddChildren,
  canShare,
  canPin,
  isMachineRoot,
  isExternalMedia,
  isArbitrarySyncFolder
};

// Source of the volume data.
enum Source {
  file,
  device,
  network,
  system
};

// File handler verbs used to describe the action that an extension performs
// over a file or directory.
enum Verb {
  open_with,
  add_to,
  pack_with,
  share_with
};

// Recent file sources allowed in getRecentFiles().
enum SourceRestriction {
  // Allows any source.
  any_source,

  // Allows source with native local file system only.
  native_source
};

// Recent file types to filter results from getRecentFiles().
enum RecentFileType {
  all,
  audio,
  image,
  video
};

enum CrostiniEventType {
  enable,
  disable,
  share,
  unshare,
  drop_failed_plugin_vm_directory_not_shared
};

enum ProviderSource {
  file,
  device,
  network
};

enum SharesheetLaunchSource {
  context_menu,
  sharesheet_button,
  unknown
};

enum IOTaskState {
  queued,
  in_progress,
  success,
  error,
  cancelled
};

enum IOTaskType {
  copy,
  delete,
  extract,
  move,
  zip
};

// These three fields together uniquely identify a task.
dictionary FileTaskDescriptor {
  DOMString appId;
  DOMString taskType;
  DOMString actionId;
};

// A file task represents an action that the file manager can perform over the
// currently selected files. See
// chrome/browser/chromeos/extensions/file_manager/file_tasks.h for details
// about how file tasks are handled.
dictionary FileTask {
  // Unique identifier for the task.
  FileTaskDescriptor descriptor;

  // Task title (ex. App name).
  DOMString title;

  // The verb that will be used to indicate the action a task performs over
  // a file (ex. "open_with").
  Verb? verb;

  // Task icon url (from chrome://extension-icon/...)
  DOMString iconUrl;

  // True if this task is a default task for the selected files.
  boolean isDefault;

  // True if this task is from generic file handler. Generic file handler is a
  // file handler which handles any type of files (e.g. extensions: ["*"],
  // types: ["*/*"]). Partial wild card (e.g. types: ["image/*"]) is not
  // generic file handler.
  boolean isGenericFileHandler;
};

// Additional entry properties.
dictionary EntryProperties {
  // Size of this file.
  double? size;

  // Timestamp of entry update time, in milliseconds past the epoch.
  double? modificationTime;

  // Timestamp of entry update time by me, in milliseconds past the epoch.
  double? modificationByMeTime;

  // URL to the Drive thumbnail image for this file.
  DOMString? thumbnailUrl;

  // URL to the Drive cropped thumbnail image for this file.
  DOMString? croppedThumbnailUrl;

  // Width, if the entry is an image.
  long? imageWidth;

  // Height, if the entry is an image.
  long? imageHeight;

  // Rotation in clockwise degrees, if the entry is an image.
  long? imageRotation;

  // True if the file is pinned in cache.
  boolean? pinned;

  // True if the file is present in cache.
  boolean? present;

  // True if the file is hosted on a server instead of local.
  boolean? hosted;

  // True if the file is available offline.
  boolean? availableOffline;

  // True if the file is available on metered connection.
  boolean? availableWhenMetered;

  // True if the file has local change (has not been fully synced to the cloud).
  boolean? dirty;

  // URL to the custom icon for this file.
  DOMString? customIconUrl;

  // Drive MIME type for this file.
  DOMString? contentMimeType;

  // True if the entry is labeled as shared-with-me.
  boolean? sharedWithMe;

  // True if the entry is labeled as shared (either from me to others or to me
  // by others.)
  boolean? shared;

  // True if the entry is starred by the user.
  boolean? starred;

  // externalfile:// URL to open the file in browser.
  DOMString? externalFileUrl;

  // https:// URL to open the file or folder in the Drive website.
  DOMString? alternateUrl;

  // https:// URL to open the file or folder in the Drive website with the
  // sharing dialog open.
  DOMString? shareUrl;

  // True if the entry can be copied by the user.
  boolean? canCopy;

  // True if the entry can be deleted by the user.
  boolean? canDelete;

  // True if the entry can be renamed by the user.
  boolean? canRename;

  // True if the entry can have children added to it by the user (directories
  // only).
  boolean? canAddChildren;

  // True if the entry can be shared by the user.
  boolean? canShare;

  // True if the entry can be pinned by the user.
  boolean? canPin;

  // True if the entry is a machine root for backup and sync.
  boolean? isMachineRoot;

  // True if the entry is a external media folder, that contains one time only
  // uploads for USB devices, SD cards etc.
  boolean? isExternalMedia;

  // True if the entry is an arbitrary sync folder.
  boolean? isArbitrarySyncFolder;
};

// Information about total and remaining size on the mount point.
dictionary MountPointSizeStats {
  // Approximate total available size on the mount point.
  double totalSize;

  // Approximate remaining available size on the mount point.
  double remainingSize;
};

// Information about a profile.
dictionary ProfileInfo {
  // Profile ID. This is currently e-mail address of the profile.
  DOMString profileId;

  // The name of the profile for display purpose.
  DOMString displayName;

  // True if the profile is the one running the current file manager instance.
  // TODO(hirono): Remove the property because of the design change of
  // multi-profile suuport.
  boolean isCurrentProfile;
};

// Represents an icon in multiple dimensions. All are optional.
dictionary IconSet {
  DOMString? icon16x16Url;
  DOMString? icon32x32Url;
};

// Mounted disk volume metadata.
dictionary VolumeMetadata {
  // ID of the disk volume.
  DOMString volumeId;

  // Id the provided file system (for provided file systems).
  DOMString? fileSystemId;

  // ID of the provider, if the volume is backed by FSP.
  DOMString? providerId;

  // Source of the volume's data.
  Source source;

  // Label of the volume (if available).
  DOMString? volumeLabel;

  // Description of the profile where the volume belongs.
  // TODO(hirono): Remove the property because of the design change of
  // multi-profile support.
  ProfileInfo profile;

  // The path to the mounted device, archive file or network resource.
  DOMString? sourcePath;

  // Type of the mounted volume.
  VolumeType volumeType;

  // Device type. Available if this is removable volume.
  DeviceType? deviceType;

  // Path to identify the device. This is consistent with DeviceEvent's
  // devicePath.
  DOMString? devicePath;

  // Whether the device is parent or not (i.e. sdb rather than sdb1).
  boolean? isParentDevice;

  // Flag that specifies if volume is mounted in read-only mode.
  boolean isReadOnly;

  // Flag that specifies if the device is write-protected.
  // Valid only for the volumes of removable device partitions.
  boolean isReadOnlyRemovableDevice;

  // Flag that specifies whether the volume contains media.
  boolean hasMedia;

  // Flag that specifies whether the volume is configurable.
  boolean configurable;

  // Flag that specifies whether the volume is watchable.
  boolean watchable;

  // Additional data about mount, for example, that the filesystem is not
  // supported.
  MountCondition? mountCondition;

  // Context in which the volume has been mounted.
  MountContext? mountContext;

  // File system type indentifier.
  DOMString? diskFileSystemType;

  // Icons for the volume.
  IconSet iconSet;

  // Drive label of the volume. Removable partitions that belong to the
  // same physical removable device share the same drive label.
  DOMString? driveLabel;

  // The path on the remote host where this volume is mounted, for crostini this
  // is the user's homedir (/home/<username>).
  DOMString? remoteMountPath;

  // Flag that specifies whether the volume is hidden from the user.
  boolean hidden;
};

// Payload data for mount event.
dictionary MountCompletedEvent {
  // Is the event raised for mounting or unmounting.
  MountCompletedEventType eventType;

  // Event type that tells listeners if mount was successful or an error
  // occurred. It also specifies the error.
  MountCompletedStatus status;

  // Metadata of the mounted volume.
  VolumeMetadata volumeMetadata;

  // Whether the volume event should be notified or not.
  boolean shouldNotify;
};

// Payload data for file transfer status updates.
dictionary FileTransferStatus {
  // URL of file that is being transfered.
  DOMString fileUrl;

  // File transfer progress state.
  TransferState transferState;

  // Approximated completed portion of the transfer operation.
  double processed;

  // Approximated total size of transfer operation.
  double total;

  // Total number of jobs.
  long numTotalJobs;

  // If true, hide when a job is completed when there are zero jobs in
  // progress. Otherwise, hide when one job is in progress.
  boolean hideWhenZeroJobs;
};

// Error during the drive sync.
dictionary DriveSyncErrorEvent {
  // Error type.
  DriveSyncErrorType type;

  // File URL of the entry that the error happens to.
  DOMString fileUrl;
};

// Confirmation dialog from Drive asking the user to accept or reject an
// action.
dictionary DriveConfirmDialogEvent {
  // Dialog type.
  DriveConfirmDialogType type;

  // File URL of the entry associated with the dialog.
  DOMString fileUrl;
};

// Payload data for copy or move status progress updates.
dictionary CopyOrMoveProgressStatus {
  // The type of the progress event.
  CopyOrMoveProgressStatusType type;

  // URL for the entry currently being copied. This field is particularly useful
  // when a directory copy is initiated with startCopy(). The field tells what
  // file/directory in that directory is now being copied.
  DOMString? sourceUrl;

  // URL for the entry currently being created. This field is particularly
  // useful when a directory copy is initiated with startCopy(). The field tells
  // what file/directory in that directory is being created. Available only for
  // end_copy_entry and success.
  DOMString? destinationUrl;

  // Number of processed bytes for the file currently being copied. Available
  // only for "progress" event. To show the progress bar, a caller needs to
  // pre-compute the size of files being copied for the file (not directory).
  double? size;

  // DOMError's name. Available only for ERROR event.
  DOMString? error;
};

// Detailed information of change.
dictionary FileChange {
  // URL of changed file (or directory).
  DOMString url;

  // Type of change, which may be multiple.
  ChangeType[] changes;
};

// Directory change notification details.
dictionary FileWatchEvent {
  // Specifies type of event that is raised.
  FileWatchEventType eventType;

  // An Entry object which represents a changed directory. The conversion into a
  // kind of FileEntry object is done in
  // file_browser_handler_custom_bindings.cc. For filesystem API's Entry
  // interface, see <a
  // href='http://www.w3.org/TR/file-system-api/#the-entry-interface'>The Entry
  // interface</a>.
  [instanceOf=Entry] object entry;

  // Detailed change information of change. It would be null if the detailed
  // information is not available.
  FileChange[]? changedFiles;
};

// Parameters passed to fileManagerPrivateInternal.getVolumeRoot function.
dictionary GetVolumeRootOptions {
  // The ID of the requested volume.
  DOMString volumeId;

  // Whether the requested file system should be writable. The default is
  // read-only.
  boolean? writable;
};

dictionary Preferences {
  boolean driveEnabled;
  boolean cellularDisabled;
  boolean searchSuggestEnabled;
  boolean use24hourClock;
  DOMString timezone;
  boolean arcEnabled;
  boolean arcRemovableMediaAccessEnabled;
  DOMString[] folderShortcuts;
};

dictionary PreferencesChange {
  boolean? cellularDisabled;
  boolean? arcEnabled;
  boolean? arcRemovableMediaAccessEnabled;
  DOMString[]? folderShortcuts;
};

dictionary SearchParams {
  // Search query.
  DOMString query;

  // ID of the search feed that should be fetched next. Value passed here should
  // be gotten from previous searchDrive call. It can be empty for the initial
  // search request.
  DOMString nextFeed;
};

dictionary SearchMetadataParams {
  // Search query. It can be empty. Any filename matches to an empty query.
  DOMString query;

  // The type of entry that is needed. Default to ALL.
  SearchType types;

  // Maximum number of results.
  long maxResults;
};

// Entry and Drive-related properties representing a search result.
dictionary DriveMetadataSearchResult {
  // A dictionary object which represents a Drive file. This will be converted
  // into a kind of FileEntry object. See
  // file_browser_handler_custom_bindings.cc for details. For filesystem API's
  // Entry interface, see <a
  // href='http://www.w3.org/TR/file-system-api/#the-entry-interface'>The Entry
  // interface</a>.
  [instanceOf=Entry] object entry;

  // The base name of a Drive file that matched the search query. The matched
  // sub strings are highlighted with <b> element. Meta characters are escaped
  // like &lt;.
  DOMString highlightedBaseName;

  // Whether the file is available while offline. May be unset if not
  // applicable.
  boolean? availableOffline;
};

dictionary DriveConnectionState {
  DriveConnectionStateType type;

  // Reasons of offline.
  DriveOfflineReason? reason;

  // Whether the device has a cellular network access or not. i.e. the |type|
  // can be 'metered' or not.
  boolean hasCellularNetworkAccess;

  // Whether or not hosted files can be pinned.
  boolean canPinHostedFiles;
};

// Device event dispatched to listeners of onDeviceChaged.  See also
// DeviceEventType to know when the event dispatched.
dictionary DeviceEvent {
  // Event type of the device event.
  DeviceEventType type;
  // Device path to identify the device.
  DOMString devicePath;
  // Human readable label for the device.
  DOMString deviceLabel;
};

// Describes an installed provider.
dictionary Provider {
  // ID of the provider.
  DOMString providerId;

  // Set of icons for the provider.
  IconSet iconSet;

  // Name of the provider.
  DOMString name;

  // Whether supports configuration dialog.
  boolean configurable;

  // Whether supports watching entries.
  boolean watchable;

  // Whether supports mounting multiple instances.
  boolean multipleMounts;

  // Source of file systems' data.
  ProviderSource source;
};

// Information about a Linux package in response to GetLinuxPackageInfo.
dictionary LinuxPackageInfo {
  DOMString name;
  DOMString version;

  // A one-line summary of the project. Almost always present.
  DOMString? summary;
  // A longer description of the project. Almost always present.
  DOMString? description;
};

// Payload data for crostini event.
dictionary CrostiniEvent {
  // Is the event raised for enable, disable, share, or unshare.
  CrostiniEventType eventType;

  // VM that this event relates to.
  DOMString vmName;

  // Paths that have been shared or unshared.
  [instanceOf=Entry] object[] entries;
};

// Represents an Android app (activity).
dictionary AndroidApp {
  // Name of the app to be shown to the user (e.g. Photos).
  DOMString name;

  // Package name (e.g. com.google.android.apps.photos).
  DOMString packageName;

  // Activity name (e.g. .PhotosPickerActivity).
  DOMString activityName;

  // App icon.
  IconSet? iconSet;
};

dictionary StreamInfo {
  // The stream type e.g., "mp3", "h264", "ogg".
  DOMString type;

  // An unfiltered string->string dictionary of tags from the stream.
  object tags;
};

dictionary AttachedImages {
  // Data encoded as a dataURL.
  DOMString data;

  // Data type.
  DOMString type;
};

dictionary MediaMetadata {
  // Content mime type.
  DOMString mimeType;

  // Defined for video. In pixels.
  long? height;
  long? width;

  // Defined for audio and video. In seconds.
  double? duration;

  // Defined for video. In degrees.
  long? rotation;

  // Defined for audio and video.
  DOMString? album;
  DOMString? artist;
  DOMString? comment;
  DOMString? copyright;
  long? disc;
  DOMString? genre;
  DOMString? language;
  DOMString? title;
  long? track;

  // All the metadata in the media file. For formats with multiple streams,
  // stream order is preserved. Container metadata is the first stream.
  StreamInfo[] rawTags;

  // Raw images embedded in the media file. This is most often audio album
  // art or video thumbnails.
  AttachedImages[] attachedImages;
};

dictionary HoldingSpaceState {
  // File system URLs of items pinned to the holding space.
  DOMString[] itemUrls;
};

dictionary OpenWindowParams {
  // The desired target directory when opening a new window. If omitted Files
  // app displays the default directory: MyFiles.
  DOMString? currentDirectoryURL;

  // The URL for a file or directory to be selected once a new window is
  // spawned.
  DOMString? selectionURL;
};

dictionary IOTaskParams {
  // Destination folder for tasks that require one. Not required by |delete|
  // task.
  [instanceof=DirectoryEntry] object? destinationFolder;
};

// IO Task Progress status, see file_manager::io_task::ProgressStatus.
dictionary ProgressStatus {

  // Type of the task sending the progress.
  IOTaskType type;

  // Current state of the task sending the progress.
  IOTaskState state;

  // Name of the first source entry.
  DOMString sourceName;

  // Number of remaining entries to be processed.
  long numRemainingItems;

  // Total number of entries to be processed.
  long itemCount;

  // Name of the destination folder for operations that transfer files to a
  // directory (e.g. copy or move).
  DOMString destinationName;

  // ProgressStatus over all |sources|.
  long bytesTransferred;

  // Total size of all |sources|.
  long totalBytes;

  // The task id for this progress status.
  long taskId;

  // The estimate time to finish the operation.
  double remainingSeconds;

  // The name of the last error that happened.
  DOMString errorName;
};

// A Guest OS that supports guest->host file sharing. This definition should
// match the one in file_manager_private.js.
dictionary MountableGuest {
  // The ID of this guest, used to identify it in calls to the backend.
  long id;

  // The localised display name of this guest as e.g. shown in the sidebar.
  DOMString displayName;
};

// Callback that does not take arguments.
callback SimpleCallback = void();

// |result| Boolean result returned by the invoked function.
callback BooleanCallback = void(boolean result);

// |result| Result of the task execution.
callback ExecuteTaskCallback = void(TaskResult result);

// |tasks| The list of matched file entries for this task.
callback GetFileTasksCallback = void(FileTask[] tasks);

// |result| Mime type of the file.
callback GetMimeTypeCallback = void(DOMString result);

// |result| Content sniffed mime type of the file.
callback GetContentMimeTypeCallback = void(DOMString result);

// |result| Metadata of the Audio or Video file.
callback GetContentMetadataCallback = void(MediaMetadata result);

// |result| Hash containing the string assets.
callback GetStringsCallback = void(object result);

// |color| String containing the color of the title bar.
callback GetFrameColorCallback = void(DOMString color);

// |success| True when file watch is successfully added.
callback AddFileWatchCallback = void(optional boolean success);

// |success| True when file watch is successfully removed.
callback RemoveFileWatchCallback = void(optional boolean success);

// |entryProperties| A dictionary containing properties of the requested
// entries.
callback GetEntryPropertiesCallback =
    void(EntryProperties[] entryProperties);

// |sourcePath| Source path of the mount.
callback AddMountCallback = void(DOMString sourcePath);

// |volumeMetadataList| The list of VolumeMetadata representing mounted volumes.
callback GetVolumeMetadataListCallback =
    void(VolumeMetadata[] volumeMetadataList);

// |disallowedEntries| A list of files not allowed to be transfered.
callback GetDisallowedTransfersCallback =
    void([instanceOf=Entry] object[] disallowedEntries);

// |copyId| ID of the copy task. Can be used to identify the progress, and to
// cancel the task.
callback StartCopyCallback = void(long copyId);

// |sizeStats| Name/value pairs of size stats. Will be undefined if stats could
// not be determined.
callback GetSizeStatsCallback = void(optional MountPointSizeStats sizeStats);

callback GetPreferencesCallback = void(Preferences result);

// |entries|
// |nextFeed| ID of the feed that contains next chunk of the search result.
//     Should be sent to the next searchDrive request to perform
//     incremental search.
callback SearchDriveCallback =
    void([instanceOf=Entry] object[] entries, DOMString nextFeed);

callback SearchDriveMetadataCallback =
    void(DriveMetadataSearchResult[] results);

callback SearchFilesCallback = void([instanceOf=Entry] object[] entries);

// |paths| A map of hash to array of drive paths. The array can be empty
// if the corresponding file is not found. However, the array will only
// contain at most one path per hash.
callback SearchFilesByHashesCallback = void(object paths);

// |zipId| The ID of the ZIP operation.
// |totalBytes| Total number of bytes to be zipped.
callback ZipSelectionCallback = void(long zipId, double totalBytes);

// |result| Less than 0 if the operation is still in progress, 0 if the
// operation finished successfully, or greater than 0 if the operation finished
// with an error.
// |bytes| Total number of bytes having been zipped so far.
callback ZipProgressCallback = void(long result, double bytes);

callback GetDriveConnectionStateCallback = void(DriveConnectionState result);

// |result| true if the length is in the valid range, false otherwise.
callback ValidatePathNameLengthCallback = void(boolean result);

// |accessToken| OAuth2 access token, or an empty string if failed to fetch.
callback RequestWebStoreAccessTokenCallback = void(DOMString accessToken);

// |url| Result url.
callback GetUrlCallback = void(DOMString url);

// |profiles| List of profile information.
// |runningProfile| ID of the profile that runs the application instance.
// |showingProfile| ID of the profile that shows the application window.
callback GetProfilesCallback = void(ProfileInfo[] profiles,
                                    DOMString runningProfile,
                                    DOMString displayProfile);

// |entries| External entries.
callback ResolveEntriesCallback =
    void([instanceOf=Entry] object[] entries);

// |checksum| Result checksum.
callback ComputeChecksumCallback = void(DOMString checksum);

// |extensions| List of providers.
callback GetProvidersCallback = void(Provider[] extensions);

// |actions| List of actions.
callback GetCustomActionsCallback = void(fileSystemProvider.Action[] actions);

// |size| result size.
callback GetDirectorySizeCallback = void(double size);

// |entries| Recently modified entries.
callback GetRecentFilesCallback = void([instanceOf=Entry] object[] entries);

// |rootDir| The root directory of the volume to which access was requested.
callback GetVolumeRootCallback =
    void([instanceof=DirectoryEntry] object rootDir);

// |entries| Entries shared with crostini container.
// |firstForSession| true the first time this is called for the session.
callback GetCrostiniSharedPathsCallback =
    void([instanceOf = Entry] object[] entries, boolean firstForSession);

// |linux_package_info| Package info for the queried package.
callback GetLinuxPackageInfoCallback =
    void(LinuxPackageInfo linux_package_info);

// |status| Result of starting the install
// |failure_reason| Reason for failure for a 'failed' status
callback InstallLinuxPackageCallback = void(
    InstallLinuxPackageResponse response, DOMString failure_reason);

// |thumbnailDataUrl| A data URL for the thumbnail; |thumbnailDataUrl| is empty
// if no thumbnail was available.
callback GetThumbnailCallback = void(DOMString thumbnailDataUrl);

// |apps| List of Android picker apps.
callback GetAndroidPickerAppsCallback = void(AndroidApp[] apps);

// |state| Describes the current holding space state.
callback HoldingSpaceStateCallback = void(HoldingSpaceState state);

// |guests| List of Guest OSs which have available mounts.
callback ListMountableGuestsCallback = void(MountableGuest[] guest);

interface Functions {
  // Logout the current user for navigating to the re-authentication screen for
  // the Google account.
  static void logoutUserForReauthentication();

  // Cancels file selection.
  static void cancelDialog();

  // Executes file browser task over selected files.
  // |descriptor| The unique identifier of task to execute.
  // |entries| Array of entries
  // |callback|
  [nocompile]
  static void executeTask(FileTaskDescriptor descriptor,
                          [instanceof=Entry] object[] entries,
                          ExecuteTaskCallback callback);

  // Sets the default task for the supplied MIME types and path extensions.
  // Lists of MIME types and URLs may contain duplicates. Additionally, the
  // list of MIME types can be empty.
  // |descriptor| The unique identifier of task to mark as default.
  // |entries| Array of selected entries to extract path extensions from.
  // |mimeTypes| Array of selected file MIME types.
  // |callback|
  [nocompile]
  static void setDefaultTask(FileTaskDescriptor descriptor,
                             [instanceof=Entry] object[] entries,
                             DOMString[] mimeTypes,
                             SimpleCallback callback);

  // Gets the list of tasks that can be performed over selected files.
  // |entries| Array of selected entries
  // |callback|
  [nocompile]
  static void getFileTasks([instanceof=Entry] object[] entries,
                           GetFileTasksCallback callback);

  // Gets the MIME type of an entry.
  // |entry| The entry to be checked.
  // |callback|
  [nocompile]
  static void getMimeType([instanceof=Entry] object entry,
                          GetMimeTypeCallback callback);

  // Gets the content sniffed MIME type of a file.
  // |fileEntry| The file entry to be checked.
  // |callback|
  [nocompile]
  static void getContentMimeType([instanceof=FileEntry] object fileEntry,
                                 GetContentMimeTypeCallback callback);

  // Gets metadata from an Audio or Video file.
  // |fileEntry| The file entry to be checked.
  // |mimeType| Content sniffed mimeType of the file.
  // |includeImages| False returns metadata tags only. True returns
  //     metadata tags and metadata (thumbnail) images.
  // |callback|
  [nocompile]
  static void getContentMetadata([instanceof=FileEntry] object fileEntry,
                                 DOMString mimeType,
                                 boolean includeImages,
                                 GetContentMetadataCallback callback);

  // Gets localized strings and initialization data.
  // |callback|
  static void getStrings(GetStringsCallback callback);

  // Adds file watch.
  // |entry| Entry to watch
  // |callback|
  [nocompile]
  static void addFileWatch([instanceof=Entry] object entry,
                           AddFileWatchCallback callback);

  // Removes file watch.
  // |entry| Watched entry
  // |callback|
  [nocompile]
  static void removeFileWatch([instanceof=Entry] object entry,
                              RemoveFileWatchCallback callback);

  // Enables the extenal file scheme necessary to initiate drags to the browser
  // window for files on the external backend.
  static void enableExternalFileScheme();

  // Requests granting R/W permissions for the passed entries. It's a best
  // effort operation. Some files may not be granted access if the url is
  // invalid or not backed by the external file system.
  // |entryUrls| Urls for the entries to be accessed.
  // |callback|
  static void grantAccess(DOMString[] entryUrls, SimpleCallback callback);

  // Selects multiple files.
  // |selectedPaths| Array of selected paths
  // |shouldReturnLocalPath| true if paths need to be resolved to local paths.
  // |callback|
  static void selectFiles(DOMString[] selectedPaths,
                          boolean shouldReturnLocalPath,
                          SimpleCallback callback);

  // Selects a file.
  // |selectedPath| A selected path
  // |index| Index of Filter
  // |forOpening| true if paths are selected for opening. false if for saving.
  // |shouldReturnLocalPath| true if paths need to be resolved to local paths.
  // |callback|
  static void selectFile(DOMString selectedPath,
                         long index,
                         boolean forOpening,
                         boolean shouldReturnLocalPath,
                         SimpleCallback callback);

  // Requests additional properties for files.
  // |entries| list of entries
  // |names| list of requested properties by their names.
  // |callback| Completion callback. May return less than requested properties
  //     if some are not available. In the same time, it can return properties
  //     which were not requested (if it's cheap to compute them).
  [nocompile]
  static void getEntryProperties(
      [instanceOf=Entry] object[] entries,
      EntryPropertyName[] names,
      GetEntryPropertiesCallback callback);

  // Pins/unpins a Drive file in the cache.
  // |entry| Entry to pin/unpin.
  // |pin| Pass true to pin the file.
  // |callback| Completion callback. $(ref:runtime.lastError) will be set if
  //     there was an error.
  [nocompile]
  static void pinDriveFile([instanceof=Entry] object entry,
                           boolean pin,
                           SimpleCallback callback);

  // Resolves entries in the isolated file system and returns corresponding
  // entries in the external file system mounted to Chrome OS file manager
  // backend. If resolving entry fails, the entry will be just ignored and the
  // corresponding entry does not appear in the result.
  [nocompile]
  static void resolveIsolatedEntries(
      [instanceOf=Entry] object[] entries,
      ResolveEntriesCallback callback);

  // Mounts a resource or a file.
  // |source| Mount point source. For compressed files it is the relative file
  //     path within the external file system.
  // |password| Optional password to decrypt the file.
  // |callback| Callback called with the source path of the mount.
  static void addMount(DOMString source, optional DOMString password,
                       AddMountCallback callback);

  // Unmounts a mounted resource.
  // |volumeId| An ID of the volume.
  static void removeMount(DOMString volumeId);

  // Get the list of mounted volumes.
  // |callback|
  static void getVolumeMetadataList(GetVolumeMetadataListCallback callback);

  // Returns the list of files not allowed to be transfered.
  // |entries| List of the source entries to be transfered.
  // |destinationEntry| Entry for the destination (parent) directory.
  // |callback| Result callback.
  [nocompile]
  static void getDisallowedTransfers(
      [instanceOf=Entry] object[] entries,
      [instanceOf=DirectoryEntry] object destinationEntry,
      GetDisallowedTransfersCallback callback);

  // Starts to copy an entry. If the source is a directory, the copy is done
  // recursively.
  // |entry| Entry of the source entry to be copied.
  // |parentEntry| Entry for the destination (parent) directory.
  // |newName| Name of the new entry. It must not contain '/'.
  // |callback| Completion callback.
  [nocompile]
  static void startCopy([instanceof=Entry] object entry,
                        [instanceof=DirectoryEntry] object parentEntry,
                        DOMString newName,
                        StartCopyCallback callback);

  // Cancels the running copy task.
  // |copyId| ID of the copy task to be cancelled.
  // |callback| Completion callback of the cancel.
  static void cancelCopy(long copyId, SimpleCallback callback);

  // Retrieves total and remaining size of a mount point.
  // |volumeId| ID of the volume to be checked.
  // |callback|
  static void getSizeStats(DOMString volumeId, GetSizeStatsCallback callback);

  // Formats a mounted volume.
  // |volumeId| ID of the volume to be formatted.
  // |filesystem| Filesystem type to be formatted to.
  // |volumeLabel| Label of the drive after formatting.
  static void formatVolume(DOMString volumeId,
                           FormatFileSystemType filesystem,
                           DOMString volumeLabel);

  // Deletes partitions of removable device, creates a new partition and format
  // it.
  // |deviceStoragePath| Storage path of the device to be formatted.
  // |filesystem| Filesystem type to be formatted to.
  // |volumeLabel| Label of the drive after formatting.
  static void singlePartitionFormat(DOMString deviceStoragePath,
                           FormatFileSystemType filesystem,
                           DOMString volumeLabel);

  // Renames a mounted volume.
  // |volumeId| ID of the volume to be renamed.
  // |newName| New name of the target volume.
  static void renameVolume(DOMString volumeId, DOMString newName);

  // Retrieves file manager preferences.
  // |callback|
  static void getPreferences(GetPreferencesCallback callback);

  // Sets file manager preferences.
  // |changeInfo|
  static void setPreferences(PreferencesChange changeInfo);

  // Performs drive content search.
  // |searchParams|
  // |callback|
  static void searchDrive(SearchParams searchParams,
                          SearchDriveCallback callback);

  // Performs drive metadata search.
  // |searchParams|
  // |callback|
  static void searchDriveMetadata(SearchMetadataParams searchParams,
                                  SearchDriveMetadataCallback callback);

  // Search files in the volume having |volumeId| by using |hashList|.
  static void searchFilesByHashes(DOMString volumeId,
                                  DOMString[] hashList,
                                  SearchFilesByHashesCallback callback);

  // Search files in My Files.
  static void searchFiles(SearchMetadataParams searchParams,
                          SearchFilesCallback callback);

  // Creates a ZIP file for the selected files and folders. Folders are
  // recursively explored and zipped. Hidden files and folders (with names
  // starting with a dot) found during recursive exploration are included too.
  // |entries| Entries of the selected files and folders to zip. They must be
  //     under the |parentEntry| directory.
  // |parentEntry| Entry of the directory containing the selected files and
  //     folders. This is where the ZIP file will be created, too.
  // |destName| Name of the destination ZIP file. The ZIP file will be created
  //     in the directory specified by |parentEntry|.
  // |callback| Callback called on completion.
  [nocompile]
  static void zipSelection([instanceof=Entry] object[] entries,
                           [instanceof=DirectoryEntry] object parentEntry,
                           DOMString destName,
                           ZipSelectionCallback callback);

  // Cancels an ongoing ZIP operation.
  // Does nothing if there is no matching ongoing ZIP operation.
  // |zipId| ID of the ZIP operation.
  static void cancelZip(long zipId);

  // Gets the progress of an ongoing ZIP operation.
  // |zipId| ID of the ZIP operation.
  static void getZipProgress(long zipId, ZipProgressCallback callback);

  // Retrieves the state of the current drive connection.
  // |callback|
  static void getDriveConnectionState(GetDriveConnectionStateCallback callback);

  // Checks whether the path name length fits in the limit of the filesystem.
  // |parentEntry| The entry of the parent directory entry.
  // |name| The name of the file.
  // |callback| Called back when the check is finished.
  [nocompile]
  static void validatePathNameLength(
      [instanceof=DirectoryEntry] object parentEntry,
      DOMString name,
      ValidatePathNameLengthCallback callback);

  // Changes the zoom factor of the Files app.
  // |operation| Zooming mode.
  static void zoom(ZoomOperationType operation);

  // Requests a Webstore API OAuth2 access token.
  // |callback|
  static void requestWebStoreAccessToken(
      RequestWebStoreAccessTokenCallback callback);

  // Requests a download url to download the file contents.
  // |entry| The entry to download.
  // |callback|
  [nocompile]
  static void getDownloadUrl([instanceof=Entry] object entry,
                             GetUrlCallback callback);

  // Obtains a list of profiles that are logged-in.
  static void getProfiles(GetProfilesCallback callback);

  // Opens inspector window.
  // |type| InspectionType which specifies how to open inspector.
  static void openInspector(InspectionType type);

  // Opens page in Settings window.
  // |sub_page| Name of a sub_page to show.
  static void openSettingsSubpage(DOMString sub_page);

  // Computes an MD5 checksum for the given file.
  // |entry| The entry of the file to checksum.
  // |callback|
  [nocompile]
  static void computeChecksum([instanceof=Entry] object entry,
                              ComputeChecksumCallback callback);

  // Returns list of available providers.
  static void getProviders(GetProvidersCallback callback);

  // Requests adding a new provided file system. On failure, sets
  // $(ref:runtime.lastError).
  static void addProvidedFileSystem(DOMString provider_id,
                                    SimpleCallback callback);

  // Requests configuring an existing volume. On failure, sets
  // $(ref:runtime.lastError).
  static void configureVolume(DOMString volumeId, SimpleCallback callback);

  // Requests list of custom actions for the specified entries. On failure, sets
  // $(ref:runtime.lastError).
  [nocompile]
  static void getCustomActions([instanceof=Entry] object[] entries,
                               GetCustomActionsCallback callback);

  // Executes a custom action for a set of entries. On failure, sets
  // $(ref:runtime.lastError).
  [nocompile]
  static void executeCustomAction([instanceof=Entry] object[] entries,
                                  DOMString actionId,
                                  SimpleCallback callback);

  // Get the total size of a directory.
  // |entry| Entry of the target directory.
  // |callback|
  [nocompile]
  static void getDirectorySize([instanceof=DirectoryEntry] object entry,
                               GetDirectorySizeCallback callback);

  // Gets recently modified files across file systems.
  // |restriction| Flag to restrict sources of recent files.
  // |fileType| Requested file type to filter recent files.
  // |callback|
  [nocompile]
  static void getRecentFiles(SourceRestriction restriction,
                             RecentFileType fileType,
                             GetRecentFilesCallback callback);

  // Requests the root directory of the volume with the ID specified in
  // |options.volumeId|.
  [nocompile]
  static void getVolumeRoot(GetVolumeRootOptions options,
                            GetVolumeRootCallback callback);

  // Starts and mounts crostini container.
  // |callback|
  static void mountCrostini(SimpleCallback callback);

  // Shares paths with crostini container.
  // |vmName| VM to share path with.
  // |entries| Entries of the files or directories to share.
  // |persist| If true, shares will persist across restarts.
  // |callback|
  [nocompile] static void sharePathsWithCrostini(
      DOMString vmName, [ instanceof = Entry] object[] entries, boolean persist,
      SimpleCallback callback);

  // Unshares path with crostini container.
  // |vmName| VM to unshare path from.
  // |entry| Entry of the file or directory to unshare.
  // |callback|
  [nocompile] static void unsharePathWithCrostini(
      DOMString vmName, [ instanceof = Entry] object entry,
      SimpleCallback callback);

  // Returns list of paths shared with crostini container.
  // |observeFirstForSession| If true, callback provides whether this is the
  // |vmName| VM to get shared paths of.
  // first time this function has been called with observeFirstForSession true.
  [nocompile] static void getCrostiniSharedPaths(
      boolean observeFirstForSession, DOMString vmName,
      GetCrostiniSharedPathsCallback callback);

  // Requests information about a Linux package. |entry| is a .deb file.
  [nocompile]
  static void getLinuxPackageInfo([instanceof=Entry] object entry,
                                  GetLinuxPackageInfoCallback callback);

  // Starts installation of a Linux package.
  [nocompile]
  static void installLinuxPackage([instanceof=Entry] object entry,
                                  InstallLinuxPackageCallback callback);

  // Imports a Crostini Image File (.tini). This overrides the existing Linux
  // apps and files.
  [nocompile]
  static void importCrostiniImage([instanceof=Entry] object entry);

  // For a file in DriveFS, retrieves its thumbnail. If |cropToSquare| is true,
  // returns a thumbnail appropriate for file list or grid views; otherwise,
  // returns a thumbnail appropriate for quickview.
  [nocompile]
  static void getDriveThumbnail([instanceof=FileEntry] object entry,
                                boolean cropToSquare,
                                GetThumbnailCallback callback);

  // For a local PDF file, retrieves its thumbnail with a given |width| and
  // |height|.
  [nocompile]
  static void getPdfThumbnail([instanceof=FileEntry] object entry,
                              long width,
                              long height,
                              GetThumbnailCallback callback);

  // Retrieves a thumbnail of an ARC DocumentsProvider file, closely matching
  // the hinted size specified by |widthHint| and |heightHint|, but not
  // necessarily the exact size. |callback| is called with thumbnail data
  // encoded as a data URL. If the document does not support thumbnails,
  // |callback| is called with an empty string.
  // Note: The thumbnail data may originate from third-party application code,
  // and is untrustworthy (Security).
  [nocompile]
  static void getArcDocumentsProviderThumbnail([instanceof=FileEntry] object entry,
                                               long widthHint,
                                               long heightHint,
                                               GetThumbnailCallback callback);

  // Returns a list of Android picker apps to be shown in file selector.
  static void getAndroidPickerApps(DOMString[] extensions,
                                   GetAndroidPickerAppsCallback callback);

  // Called when the user selects an Android picker app in file selector.
  static void selectAndroidPickerApp(AndroidApp androidApp,
                                     SimpleCallback callback);

  // Return true if sharesheet contains share targets for entries.
  // |entries| Array of selected entries
  // |callback| is called with error in case of failure and with no arguments
  // if successfully launched the Sharesheet dialog, but before user has
  // finished the sharing.
  [nocompile]
  static void sharesheetHasTargets([instanceof=Entry] object[] entries,
                           BooleanCallback callback);

  // Invoke Sharesheet for selected files.
  // |entries| Array of selected entries.
  // |launchSource| Source from which sharesheet was invoked.
  // |callback|
  [nocompile]
  static void invokeSharesheet([instanceof=Entry] object[] entries,
                               SharesheetLaunchSource launchSource,
                               SimpleCallback callback);

  // Adds or removes a list of entries to temporary holding space. Any entries
  // whose current holding space state matches the intended state will be
  // skipped.
  // |entries| The list of entries whose holding space needs to be updated.
  // |add| Whether items should be added or removed from the holding space.
  // |callback| Completion callback.
  [nocompile]
  static void toggleAddedToHoldingSpace([instanceOf=Entry] object[] entries,
                                        boolean added,
                                        optional SimpleCallback callback);

  // Retrieves the current holding space state, for example the list of items
  // the holding space currently contains.
  // |callback| The result callback.
  static void getHoldingSpaceState(HoldingSpaceStateCallback callback);

  // Returns color via `callback` for Files app foreground window frame.
  static void getFrameColor(GetFrameColorCallback callback);

  // Returns true via `callback` if tablet mode is enabled, false otherwise.
  static void isTabletModeEnabled(BooleanCallback callback);

  // Notifies the browser of the result of a dialog displayed earlier as a
  // result of the onDriveConfirmDialog event.
  static void notifyDriveDialogResult(DriveDialogResult result);

  // Opens a new browser tab and navigates to `url`.
  static void openURL(DOMString url);

  // Creates a new Files app window in the directory provided in `params`.
  static void openWindow(OpenWindowParams params, BooleanCallback callback);

  // Starts an I/O task of type |type| on |entries|. Task type specific
  // parameters are passed via |params|.
  [nocompile]
  static void startIOTask(
      IOTaskType type,
      [instanceof=Entry] object[] entries,
      IOTaskParams params);

  // Cancels an I/O task by id. Task ids are communicated to the Files App in
  // each I/O task's progress status.
  static void cancelIOTask(long taskId);

  // Lists mountable Guest OSs.
  static void listMountableGuests(ListMountableGuestsCallback callback);
};

// Events supported by fileManagerPrivate API. These events are broadcasted.
// See the note at the top of the file with regards implications of event
// broadcasting to applications that can use fileManagerPrivate Event API.
interface Events {
  static void onMountCompleted(MountCompletedEvent event);

  static void onFileTransfersUpdated(FileTransferStatus event);

  static void onPinTransfersUpdated(FileTransferStatus event);

  static void onCopyProgress(long copyId, CopyOrMoveProgressStatus status);

  static void onDirectoryChanged(FileWatchEvent event);

  static void onPreferencesChanged();

  static void onDriveConnectionStatusChanged();

  static void onDeviceChanged(DeviceEvent event);

  static void onDriveSyncError(DriveSyncErrorEvent event);

  static void onDriveConfirmDialog(DriveConfirmDialogEvent event);

  static void onAppsUpdated();

  static void onCrostiniChanged(CrostiniEvent event);

  static void onTabletModeChanged(boolean enabled);

  static void onIOTaskProgressStatus(ProgressStatus status);

  // Event broadcast when the list of Guest OSs that support Guest->Host file
  // sharing changes.
  static void onMountableGuestsChanged(MountableGuest[] guests);
};
};