// Copyright 2013 The Chromium Authors
// 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/ash/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, guest_os };

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

// List of device connection statuses.
enum DeviceConnectionState {OFFLINE, ONLINE};

// 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 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 MountError {
  success,
  in_progress,
  unknown_error,
  internal_error,
  invalid_argument,
  invalid_path,
  path_already_mounted,
  path_not_mounted,
  directory_creation_failed,
  invalid_mount_options,
  insufficient_permissions,
  mount_program_not_found,
  mount_program_failed,
  invalid_device_path,
  unknown_filesystem,
  unsupported_filesystem,
  need_password,
  cancelled,
  busy,
  corrupted
};

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

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

// The response when starting installing a Linux package.
enum InstallLinuxPackageStatus {
  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 for the user to sync a file.
  no_server_space,
  // There is no server space for the organization to sync a file.
  no_server_space_organization,
  // There is no local space to sync a file.
  no_local_space,
  // There is no space left on a shared drive.
  no_shared_drive_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,
  syncStatus,
  progress,
  shortcut,
  syncCompletedTime
};

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

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

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

// File categories to filter results from getRecentFiles().
enum FileCategory {
  all,
  audio,
  image,
  video,
  document
};

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,
  scanning,
  in_progress,
  paused,
  success,
  error,
  need_password,
  cancelled
};

enum IoTaskType {
  copy,
  delete,
  empty_trash,
  extract,
  move,
  restore,
  restore_to_destination,
  trash,
  zip
};

enum PolicyErrorType {
  dlp,
  enterprise_connectors,
  dlp_warning_timeout
};

enum PolicyDialogType {
  warning,
  error
};

enum RecentDateBucket {
  today,
  yesterday,
  earlier_this_week,
  earlier_this_month,
  earlier_this_year,
  older
};

enum VmType { termina, plugin_vm, borealis, bruschetta, arcvm };

enum UserType {
  // User doesn't belong to any organization.
  unmanaged,
  // User is a member of an organization.
  organization
};

enum DlpLevel {
  // Report every action to the admin, doesn't affect the user.
  report,
  // Warn the user on every action.
  warn,
  // Block the user on every action.
  block,
  // No restriction.
  allow
};

enum SyncStatus {
  // No sync status available for file.
  not_found,
  // File is queued up for syncing.
  queued,
  // File is currently being synced.
  in_progress,
  // File is done syncing.
  completed,
  // There was an error syncing the file.
  error
};

// Describes how admin policy affects the default task in a ResultingTasks.
// See chrome/browser/ash/file_manager/file_tasks.h for details.
enum PolicyDefaultHandlerStatus {
  default_handler_assigned_by_policy,
  incorrect_assignment
};

// Describes the stage the bulk pinning manager is in. This enum should be kept
// in sync with chromeos/ash/components/drivefs/mojom/pin_manager_types.mojom.
enum BulkPinStage {
  // Initial stage.
  stopped,

  // Paused because of unfavorable network conditions.
  paused_offline,
  // Paused due to battery saver mode active.
  paused_battery_saver,

  // In-progress stages.
  getting_free_space,
  listing_files,
  syncing,

  // Final success stage.
  success,

  // Final error stages.
  not_enough_space,
  cannot_get_free_space,
  cannot_list_files,
  cannot_enable_docs_offline
};

// The default location/volume that the user should use.
// It's usually MyFiles. When SkyVault is enabled the admin might
// choose between Google Drive and OneDrive.
// NOTE: This is independent of the Downloads folder which is mostly used
// in the browser.
enum DefaultLocation {
  my_files,
  google_drive,
  onedrive
};

// The value of the SkyVault LocalFilesMigrationDestination policy.
enum MigrationDestination {
  not_specified,
  google_drive,
  onedrive,
  delete
};

// 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/ash/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;

  // 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;

  // True if this is task is blocked by Data Leak Prevention (DLP).
  boolean? isDlpBlocked;
};

// Represents a set of tasks capable of handling file entries.
// See chrome/browser/ash/file_manager/file_tasks.h for details.
dictionary ResultingTasks {
  FileTask[] tasks;

  // Note that this field is non-null if and only if at least one entry has been affected by policy.
  PolicyDefaultHandlerStatus? policyDefaultHandlerStatus;
};

// 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;

  // Date bucket calculated by |modificationTime| or |modificationByMeTime|.
  RecentDateBucket? recentDateBucket;

  // 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;

  // Sync status for files tracked by different cloud filesystem providers.
  SyncStatus? syncStatus;

  // Progress representing some ongoing operation with the file.
  // E.g., pasting, syncing. Note: currently, this is exclusively being used
  // for Drive syncing.
  double? progress;

  // Time in milliseconds since the epoch when the file last received a
  // "completed" sync status.
  double? syncCompletedTime;

  // True if the entry is a shortcut.
  boolean? shortcut;
};

// 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;
};

dictionary SearchDriveResponse {
  // Search results.
  [instanceOf=Entry] object[] entries;

  // ID of the feed that contains next chunk of the search result.
  // Should be sent to the next searchDrive request to perform
  // incremental search.
  DOMString nextFeed;
};

// Free and total space available in Drive relative to both the user and their
// organization, if they belong to one.
dictionary DriveQuotaMetadata {
  UserType userType;

  // How much space the individual user, or shared drive has used.
  double usedBytes;
  // The individual user, or shared drive limit. -1 means infinite.
  double totalBytes;

  // The following two fields only have meaning if user_type is kOrganization.
  // Whether the organization has exceeded its storage limit.
  boolean organizationLimitExceeded;
  // Name of the organization the user belongs to.
  DOMString organizationName;
};

// 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;
};

// The return data for getProfiles() API.
dictionary ProfilesResponse {
  // List of profile information.
  ProfileInfo[] profiles;

  // ID of the profile that runs the application instance.
  DOMString currentProfileId;

  // ID of the profile that shows the application window.
  DOMString displayedProfileId;
};

// 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.
  MountError? 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;

  // Type of the VM which owns this volume.
  VmType? vmType;
};

// 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.
  MountError status;

  // Metadata of the mounted volume.
  VolumeMetadata volumeMetadata;

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

// Payload data for aggregate file transfer status updates.
dictionary FileTransferStatus {
  // URL of file that is being transferred.
  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;

  // Indicates whether a notification should be shown for the transfer update.
  boolean showNotification;

  // 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;
};

// Information about the syncing state of an individual file.
dictionary SyncState {
  // URL of file that is being transferred.
  DOMString fileUrl;

  // File transfer progress state.
  SyncStatus syncStatus;

  // Transfer progress so far. Ranges from 0 to 1.
  double progress;
};

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

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

  // Shared drive name if the error relates to a shared drive.
  DOMString? sharedDrive;
};

// 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;
};

// 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 driveSyncEnabledOnMeteredNetwork;
  boolean searchSuggestEnabled;
  boolean use24hourClock;
  DOMString timezone;
  boolean arcEnabled;
  boolean arcRemovableMediaAccessEnabled;
  DOMString[] folderShortcuts;
  boolean trashEnabled;
  double officeFileMovedOneDrive;
  double officeFileMovedGoogleDrive;
  boolean driveFsBulkPinningAvailable;
  boolean driveFsBulkPinningEnabled;
  boolean localUserFilesAllowed;
  DefaultLocation defaultLocation;
  MigrationDestination skyVaultMigrationDestination;
  DOMString? skyVaultMigrationStartTime;
};

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

dictionary SearchParams {
  // Search query.
  DOMString query;

  // The category of files to which the search is limited.
  FileCategory? category;

  // The minimum modified time of the files to be returned
  double? modifiedTimestamp;

  // 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 {
  // Optional root directory from which to start the search. If not present,
  // the search begins at the local root.
  [instanceOf=DirectoryEntry] object? rootDir;

  // 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;

  // Modified timestamp. The file must have modified timestamp more recent
  // than this to be included in results.
  double? modifiedTimestamp;

  // The category of files to which the search is limited.
  FileCategory? category;
};

// 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;
};

// 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;
};

// chrome/common/extensions/api/file_system_provider.idl:Action
// Information about an action for an entry.
dictionary FileSystemProviderAction {
  // The identifier of the action. Any string or $(ref:CommonActionId) for
  // common actions.
  DOMString id;

  // The title of the action. It may be ignored for common actions.
  DOMString? title;
};

// 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;

  // Name of the container this event relates to.
  DOMString containerName;

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

dictionary CrostiniSharedPathResponse {
  // Entries shared with crostini container.
  [instanceOf=Entry] object[] entries;

  // true the first time this is called for the session.
  boolean firstForSession;
};

// 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;

  // Password used for unpacking encrypted archives.
  DOMString? password;

  // Whether to display a notification in the UI. This does not stop the
  // IOProgressStatus event propagating instead it provides a true boolean on
  // the event that the UI can choose to show / hide the notification.
  boolean? showNotification;
};

// Holds information about data protection policy errors, see file_manager::io_task::PolicyError.
dictionary PolicyError {
  // Type of the error.
  PolicyErrorType type;
  // The number of files blocked by the policy.
  long policyFileCount;
  // The name of the first blocked file. Used for notifications.
  DOMString fileName;
  // Normally the review button is only shown when `policyFileCount` is >1, this option allows to force
  // the display of the review button irrespective of other conditions.
  boolean alwaysShowReview;
};

// IO task state::PAUSED name conflict parameters, see file_manager::io_task::ConflictPauseParams.
dictionary ConflictPauseParams {
  // The conflict file name.
  DOMString? conflictName;

  // True if the conflict file name is a directory.
  boolean? conflictIsDirectory;

  // Set true if there are potentially multiple conflicted file names.
  boolean? conflictMultiple;

  // The conflict copy or move target URL.
  DOMString? conflictTargetUrl;
};

// IO task state::PAUSED policy parameters, see file_manager::io_task::PolicyPauseParams.
dictionary PolicyPauseParams {
  // One of DLP or Enterprise Connectors.
  PolicyErrorType type;
  // The number of files under warning restriction.
  long policyFileCount;
  // The name of the first file under warning restriction. Used for notifications.
  DOMString fileName;
  // Normally the review button is only shown when `policyFileCount` is >1, this option allows to force
  // the display of the review button irrespective of other conditions.
  boolean alwaysShowReview;
};

// IO task state::PAUSED parameters, see file_manager::io_task::PauseParams.
dictionary PauseParams {
  // Set iff pausing due to name conflict.
  ConflictPauseParams? conflictParams;
  // Set iff pausing due to policy.
  PolicyPauseParams? policyParams;
};

// Resume IO Task parameters, see file_manager::io_task::ConflictResumeParams.
dictionary ConflictResumeParams {
  // How to resolve a CopyOrMoveIOTask file name conflict: either 'keepboth'
  // or 'replace'.
  DOMString? conflictResolve;

  // Set true if conflictResolve should apply to future file name conflicts.
  boolean? conflictApplyToAll;
};

// Resume IO Task parameters, see file_manager::io_task::PolicyResumeParams.
dictionary PolicyResumeParams {
  PolicyErrorType type;
};

// Resume IO Task parameters, see file_manager::io_task::ResumeParams.
dictionary ResumeParams {
  // Set iff paused due to name conflict.
  ConflictResumeParams? conflictParams;
  // Set iff paused due to policy.
  PolicyResumeParams? policyParams;
};

// 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;

  // Type of policy error that occurred, if any.
  // Used only if Data Leak Prevention or Enterprise Connectors policies apply.
  PolicyError? policyError;

  // 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;

  // Number of sources scanned. Only used when in SCANNING state.
  // When scanning files, the progress is roughly the percentage of the
  // number of scanned items out of the total items. This isn't always
  // accurate, e.g. when uploading entire folders or because some items
  // are not scanned at all. The goal is to show the user that some
  // progress is happening.
  long sourcesScanned;

  // Whether notifications should be shown on progress status.
  boolean showNotification;

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

  // I/O task state::PAUSED parameters.
  PauseParams? pauseParams;

  // The files affected by the IOTask. Currently only returned for TrashIOTask.
  [instanceOf=Entry] object[]? outputs;

  // List of files skipped during the operation because we couldn't decrypt
  // them.
  DOMString[] skippedEncryptedFiles;

  // Volume id of the destination for operations that transfer files to a
  // directory (e.g. copy or move).
  DOMString destinationVolumeId;
};

dictionary DlpMetadata {
  // The source URL of the file, if it's been downloaded.
  DOMString sourceUrl;

  // True if there is any DLP policy on the file, false otherwise.
  boolean isDlpRestricted;

  // True if the file cannot be accessed by a specific destination,
  // which is passed when collecting the metadata.
  boolean isRestrictedForDestination;
};

dictionary DlpRestrictionDetails {
  // The level for which the restriction is enforced.
  DlpLevel level;

  // List of URLs for which the restriction is enforced.
  DOMString[] urls;

  // List of components for which the restriction is enforced.
  VolumeType[] components;
};

dictionary DialogCallerInformation {
  // The URL of the caller.
  DOMString? url;

  // The component type of the caller.
  VolumeType? component;
};

// 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;

  // The type of the VM backing this guest.
  VmType vmType;
};

dictionary ParsedTrashInfoFile {
  // The entry that the trashed file should be restored to. This does not exist
  // but is used to identify whether the parent location still exists and
  // identify the file name to restore to.
  [instanceOf=Entry] object restoreEntry;

  // The file name for the .trashinfo.
  DOMString trashInfoFileName;

  // The date the file was originally deleted.
  double deletionDate;
};

// The current progress of the bulk pinning manager. This is a subset of the
// Progress struct in chromeos/ash/components/drivefs/drivefs_pinning_manager.h
dictionary BulkPinProgress {
  // The stage the bulk pin manager is in.
  BulkPinStage stage;

  // Estimated amount of free space on the stateful partition in bytes.
  double freeSpaceBytes;

  // Estimated amount of free space required in order to successfully complete
  // pinning.
  double requiredSpaceBytes;

  // Estimated amount of bytes remaining to be downloaded in order to
  // successfully complete pinning.
  double bytesToPin;

  // Bytes that have been downloaded so far.
  double pinnedBytes;

  // Total number of files to pin.
  long filesToPin;

  // Show the total number of files enumerated during the Listing files stage.
  long listedFiles;

  // Estimated time remaining to pin all the `bytesToPin`.
  double remainingSeconds;

  // Should the bulk-pinning manager actually pin files, or should it stop after
  // checking the space requirements?
  boolean shouldPin;

  // Has the bulk-pinning manager ever emptied its set of tracked items?
  boolean emptiedQueue;
};

// Used by EntryData to store the file system of the entry.
dictionary FileSystemData {
  // Name of the file system. Will be unique.
  DOMString name;

  // File system URL of the root entry of the file system.
  DOMString rootUrl;
};

// Representation of an entry as a replacement for File/Directory Entries.
dictionary EntryData {
  // File system URL of the entry.
  DOMString entryUrl;

  // If false, the entry is a file.
  boolean isDirectory;

  // Localized name of the entry for display.
  DOMString name;

  // Information about the filesystem the entry is located in.
  FileSystemData filesystem;
};

// 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);

// |resultingTasks| The list of matched file entries for this task.
callback GetFileTasksCallback = void(ResultingTasks resultingTasks);

// |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);

// |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);

// |dlpMetadata| A list of DlpMetadata containing DLP information about
// the entries.
callback GetDlpMetadataCallback =
    void(DlpMetadata[] dlpMetadata);

// |restrictionDetails| A list of DlpRestrictionDetails containing
// summarized restriction information about an entry.
callback GetDlpRestrictionDetailsCallback =
    void(DlpRestrictionDetails[] restrictionDetails);

// |blockedComponents| A list of components (subset of VolumeType) to which
// transferring an Entry is blocked by Data Leak Prevention (DLP) policy.
callback GetDlpBlockedComponentsCallback = void(VolumeType[] blockedComponents);

// |caller| Either the URL or a component (subset of VolumeType) of
// the caller that created the dialog (Save As/File Picker).
callback GetDialogCallerCallback = void(DialogCallerInformation caller);

// |taskId| ID of the task that was started. Can be used to cancel ongoing task.
callback IOTaskIdCallback = void(long taskId);

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

// |driveQuotaMetadata| Name/value pairs of drive quota metadata. Will be
// undefined if quota metadata could not be determined.
callback GetDriveQuotaMetadataCallback = void(optional DriveQuotaMetadata driveQuotaMetadata);

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(SearchDriveResponse response);

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);

callback GetDeviceConnectionStateCallback = void(DeviceConnectionState result);

callback GetDriveConnectionStateCallback = void(DriveConnectionState result);

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

callback GetProfilesCallback = void(ProfilesResponse response);

// |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(FileSystemProviderAction[] 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);

callback GetCrostiniSharedPathsCallback =
    void(CrostiniSharedPathResponse response);

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

callback InstallLinuxPackageCallback = void(InstallLinuxPackageStatus status);

// |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);

callback ParseTrashInfoFilesCallback = void(ParsedTrashInfoFile[] files);

callback GetBulkPinProgressCallback = void(BulkPinProgress progress);

interface Functions {
  // 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, doesNotSupportPromises]
  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, doesNotSupportPromises]
  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
  // |dlpSourceUrls| Array of source URLs corresponding to the entries, used to
  // check Data Leak Prevention (DLP) restrictions
  // |callback|
  [nocompile, doesNotSupportPromises]
  static void getFileTasks([instanceOf=Entry] object[] entries,
                           DOMString[] dlpSourceUrls,
                           GetFileTasksCallback callback);

  // Gets the MIME type of an entry.
  // |entry| The entry to be checked.
  // |callback|
  static void getMimeType(DOMString url,
                          GetMimeTypeCallback callback);

  // Gets the content sniffed MIME type of a file.
  // |fileEntry| The file entry to be checked.
  // |callback|
  [nocompile, doesNotSupportPromises]
  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, doesNotSupportPromises]
  static void getContentMetadata([instanceOf=FileEntry] object fileEntry,
                                 DOMString mimeType,
                                 boolean includeImages,
                                 GetContentMetadataCallback callback);

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

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

  // Removes file watch.
  // |entry| Watched entry
  // |callback|
  [nocompile, doesNotSupportPromises]
  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|
  [doesNotSupportPromises]
  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|
  [doesNotSupportPromises]
  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|
  [doesNotSupportPromises]
  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, doesNotSupportPromises]
  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, doesNotSupportPromises]
  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, doesNotSupportPromises]
  static void resolveIsolatedEntries(
      [instanceOf=Entry] object[] entries,
      ResolveEntriesCallback callback);

  // Mounts a resource or an archive.
  // |fileUrl| Mount point source.
  // |password| Optional password to decrypt the archive.
  // |callback| Callback called with the source path of the mount.
  [doesNotSupportPromises]
  static void addMount(DOMString fileUrl, optional DOMString password,
                       AddMountCallback callback);

  // Cancels an archive mounting operation.
  // |fileUrl| Mount point source. Should be same as the one passed to addMount.
  // |callback|
  [doesNotSupportPromises]
  static void cancelMounting(DOMString fileUrl, SimpleCallback callback);

  // Unmounts a mounted resource.
  // |volumeId| An ID of the volume.
  [doesNotSupportPromises]
  static void removeMount(DOMString volumeId, SimpleCallback callback);

  // Get the list of mounted volumes.
  // |callback|
  [doesNotSupportPromises]
  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.
  // |isMove| True if the operation is move, false otherwise.
  // |callback| Result callback.
  [nocompile, doesNotSupportPromises]
  static void getDisallowedTransfers(
      [instanceOf=Entry] object[] entries,
      [instanceOf=DirectoryEntry] object destinationEntry,
      boolean isMove,
      GetDisallowedTransfersCallback callback);

  // Returns the list of DlpMetadata containing DLP information
  // about the entries.
  // |entries| List of the source entries to be checked.
  // |callback| Result callback.
  [nocompile, doesNotSupportPromises]
  static void getDlpMetadata(
      [instanceOf=Entry] object[] entries,
      GetDlpMetadataCallback callback);

  // Retrieves Data Leak Prevention (DLP) restriction details.
  // |sourceUrl| Source URL of the Entry for which the details should be shown.
  // |callback| Result callback.
  [doesNotSupportPromises]
  static void getDlpRestrictionDetails(
      DOMString sourceUrl,
      GetDlpRestrictionDetailsCallback callback);

  // Retrieves the list of components to which the transfer of an Entry
  // is blocked by Data Leak Prevention (DLP) policy.
  // |sourceUrl| Source URL of the Entry that should be checked.
  // |callback| Result callback.
  [doesNotSupportPromises]
  static void getDlpBlockedComponents(
      DOMString sourceUrl,
      GetDlpBlockedComponentsCallback callback);

  // Retrieves the caller that created the dialog (Save As/File Picker).
  // |callback| Result callback.
  [doesNotSupportPromises]
  static void getDialogCaller(GetDialogCallerCallback callback);

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


  // Retrieves metadata about the user's Drive volume's quota.
  // |entry| If entry is within a Shared Drive, then the applicable shared
  // drive quota is returned, else the overall Drive quota is returned.
  // |callback|
  [nocompile, doesNotSupportPromises]
  static void getDriveQuotaMetadata([instanceOf=Entry] object entry,
                                    GetDriveQuotaMetadataCallback 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|
  [doesNotSupportPromises]
  static void getPreferences(GetPreferencesCallback callback);

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

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

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

  // Search files in MyFiles.
  [nocompile, doesNotSupportPromises]
  static void searchFiles(SearchMetadataParams searchParams,
                          SearchFilesCallback callback);

  // Retrieves the current device connection status.
  // |callback|
  [doesNotSupportPromises]
  static void getDeviceConnectionState(GetDeviceConnectionStateCallback callback);

  // Retrieves the state of the current drive connection.
  // |callback|
  [doesNotSupportPromises]
  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, doesNotSupportPromises]
  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);

  // Obtains a list of profiles that are logged-in.
  [doesNotSupportPromises]
  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.
  // |subPage| Name of a subPage to show.
  static void openSettingsSubpage(DOMString subPage);

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

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

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

  // Requests list of custom actions for the specified entries. On failure, sets
  // $(ref:runtime.lastError).
  [nocompile, doesNotSupportPromises]
  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, doesNotSupportPromises]
  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, doesNotSupportPromises]
  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.
  // |query| When not empty, removes files with non-matching names.
  // |cutoffDays| Specifies oldest modification time.
  // |callback| Called with zero or more matched files.
  [nocompile, doesNotSupportPromises]
  static void getRecentFiles(SourceRestriction restriction,
                             DOMString query,
                             long cutoffDays,
                             FileCategory fileCategory,
                             boolean invalidateCache,
                             GetRecentFilesCallback callback);

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

  // Starts and mounts crostini container.
  // |callback|
  [doesNotSupportPromises]
  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, doesNotSupportPromises]
  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, doesNotSupportPromises]
  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, doesNotSupportPromises]
  static void getCrostiniSharedPaths(boolean observeFirstForSession,
                                     DOMString vmName,
                                     GetCrostiniSharedPathsCallback callback);

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

  // Starts installation of a Linux package.
  [nocompile, doesNotSupportPromises]
  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);

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

  // Called when the user selects an Android picker app in file selector.
  [doesNotSupportPromises]
  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.
  static void sharesheetHasTargets(DOMString[] fileUrls,
                                   BooleanCallback callback);

  // Invoke Sharesheet for selected files.
  // |entries| Array of selected entries.
  // |launchSource| Source from which sharesheet was invoked.
  // |dlpSourceUrls| Array of source URLs corresponding to the entries, used to
  // check Data Leak Prevention (DLP) restrictions
  // |callback|
  static void invokeSharesheet(DOMString[] fileUrls,
                               SharesheetLaunchSource launchSource,
                               DOMString[] dlpSourceUrls,
                               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, doesNotSupportPromises]
  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.
  [doesNotSupportPromises]
  static void getHoldingSpaceState(HoldingSpaceStateCallback callback);

  // Returns true via `callback` if tablet mode is enabled, false otherwise.
  [doesNotSupportPromises]
  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);

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

  // Opens the feedback report window.
  static void sendFeedback();

  // Starts an I/O task of type |type| on |entries|. Task type specific
  // parameters are passed via |params|.
  [nocompile, doesNotSupportPromises]
  static void startIOTask(
      IoTaskType type,
      [instanceOf=Entry] object[] entries,
      IoTaskParams params,
      optional IOTaskIdCallback callback);

  // 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);

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

  // Notifies the browser that any info still stored about an already completed
  // I/O task identified by |taskId| can be cleared.
  [doesNotSupportPromises]
  static void dismissIOTask(long taskId, SimpleCallback callback);

  // Shows a policy dialog for a task. Task ids are communicated to the Files
  // App in each I/O task's progress status.
  [doesNotSupportPromises]
  static void showPolicyDialog(
      long taskId,
      PolicyDialogType type,
      SimpleCallback callback);

  // Makes I/O tasks in state::PAUSED emit (broadcast) their current I/O task
  // progress status.
  [doesNotSupportPromises]
  static void progressPausedTasks(SimpleCallback callback);

  // Lists mountable Guest OSs.
  [doesNotSupportPromises]
  static void listMountableGuests(ListMountableGuestsCallback callback);

  // Starts and mounts the target Guest OS.
  // |callback|
  [doesNotSupportPromises]
  static void mountGuest(long id, SimpleCallback callback);

  // Tells DriveFS to update its cached pin states of hosted files (once).
  static void pollDriveHostedFilePinStates();

  // Opens the dialog to manage the currently syncing folders.
  static void openManageSyncSettings();

  // Validates and parses the supplied `entries` as .trashinfo files.
  [nocompile, doesNotSupportPromises]
  static void parseTrashInfoFiles([instanceOf=Entry] object[] entries,
                                  ParseTrashInfoFilesCallback callback);

  // Returns the current progress of the bulk pinning manager.
  [doesNotSupportPromises]
  static void getBulkPinProgress(GetBulkPinProgressCallback callback);

  // Starts calculating the space required to pin all the items in a users My
  // drive.
  [doesNotSupportPromises]
  static void calculateBulkPinRequiredSpace(SimpleCallback 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 onIndividualFileTransfersUpdated(SyncState[] event);

  static void onDirectoryChanged(FileWatchEvent event);

  static void onPreferencesChanged();

  static void onDeviceConnectionStatusChanged(DeviceConnectionState state);

  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);

  static void onBulkPinProgress(BulkPinProgress progress);
};
};