@webref/idl 3.29.0 → 3.30.0

package/attribution-reporting-api.idl

@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Attribution Reporting (https://wicg.github.io/attribution-reporting-api/)
+
+interface mixin HTMLAttributionSrcElementUtils {
+    [CEReactions] attribute USVString attributionSrc;
+};
+
+HTMLAnchorElement includes HTMLAttributionSrcElementUtils;
+HTMLImageElement includes HTMLAttributionSrcElementUtils;
+HTMLScriptElement includes HTMLAttributionSrcElementUtils;

package/audio-output.idl

@@ -0,0 +1,17 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Audio Output Devices API (https://w3c.github.io/mediacapture-output/)
+
+partial interface HTMLMediaElement {
+  [SecureContext] readonly attribute DOMString sinkId;
+  [SecureContext] Promise<undefined> setSinkId (DOMString sinkId);
+};
+
+partial interface MediaDevices {
+  Promise<MediaDeviceInfo> selectAudioOutput(optional AudioOutputOptions options = {});
+};
+
+dictionary AudioOutputOptions {
+  DOMString deviceId = "";
+};

package/autoplay-detection.idl

@@ -0,0 +1,19 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Autoplay Policy Detection (https://w3c.github.io/autoplay/)
+
+enum AutoplayPolicy {
+  "allowed",
+  "allowed-muted",
+  "disallowed"
+};
+
+enum AutoplayPolicyMediaType { "mediaelement", "audiocontext" };
+
+[Exposed=Window]
+partial interface Navigator {
+  AutoplayPolicy getAutoplayPolicy(AutoplayPolicyMediaType type);
+  AutoplayPolicy getAutoplayPolicy(HTMLMediaElement element);
+  AutoplayPolicy getAutoplayPolicy(AudioContext context);
+};

package/background-fetch.idl

@@ -0,0 +1,89 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Background Fetch (https://wicg.github.io/background-fetch/)
+
+partial interface ServiceWorkerGlobalScope {
+  attribute EventHandler onbackgroundfetchsuccess;
+  attribute EventHandler onbackgroundfetchfail;
+  attribute EventHandler onbackgroundfetchabort;
+  attribute EventHandler onbackgroundfetchclick;
+};
+
+partial interface ServiceWorkerRegistration {
+  readonly attribute BackgroundFetchManager backgroundFetch;
+};
+
+[Exposed=(Window,Worker)]
+interface BackgroundFetchManager {
+  Promise<BackgroundFetchRegistration> fetch(DOMString id, (RequestInfo or sequence<RequestInfo>) requests, optional BackgroundFetchOptions options = {});
+  Promise<BackgroundFetchRegistration?> get(DOMString id);
+  Promise<sequence<DOMString>> getIds();
+};
+
+dictionary BackgroundFetchUIOptions {
+  sequence<ImageResource> icons;
+  DOMString title;
+};
+
+dictionary BackgroundFetchOptions : BackgroundFetchUIOptions {
+  unsigned long long downloadTotal = 0;
+};
+
+[Exposed=(Window,Worker)]
+interface BackgroundFetchRegistration : EventTarget {
+  readonly attribute DOMString id;
+  readonly attribute unsigned long long uploadTotal;
+  readonly attribute unsigned long long uploaded;
+  readonly attribute unsigned long long downloadTotal;
+  readonly attribute unsigned long long downloaded;
+  readonly attribute BackgroundFetchResult result;
+  readonly attribute BackgroundFetchFailureReason failureReason;
+  readonly attribute boolean recordsAvailable;
+
+  attribute EventHandler onprogress;
+
+  Promise<boolean> abort();
+  Promise<BackgroundFetchRecord> match(RequestInfo request, optional CacheQueryOptions options = {});
+  Promise<sequence<BackgroundFetchRecord>> matchAll(optional RequestInfo request, optional CacheQueryOptions options = {});
+};
+
+enum BackgroundFetchResult { "", "success", "failure" };
+
+enum BackgroundFetchFailureReason {
+  // The background fetch has not completed yet, or was successful.
+  "",
+  // The operation was aborted by the user, or abort() was called.
+  "aborted",
+  // A response had a not-ok-status.
+  "bad-status",
+  // A fetch failed for other reasons, e.g. CORS, MIX, an invalid partial response,
+  // or a general network failure for a fetch that cannot be retried.
+  "fetch-error",
+  // Storage quota was reached during the operation.
+  "quota-exceeded",
+  // The provided downloadTotal was exceeded.
+  "download-total-exceeded"
+};
+
+[Exposed=(Window,Worker)]
+interface BackgroundFetchRecord {
+  readonly attribute Request request;
+  readonly attribute Promise<Response> responseReady;
+};
+
+[Exposed=ServiceWorker]
+interface BackgroundFetchEvent : ExtendableEvent {
+  constructor(DOMString type, BackgroundFetchEventInit init);
+  readonly attribute BackgroundFetchRegistration registration;
+};
+
+dictionary BackgroundFetchEventInit : ExtendableEventInit {
+  required BackgroundFetchRegistration registration;
+};
+
+[Exposed=ServiceWorker]
+interface BackgroundFetchUpdateUIEvent : BackgroundFetchEvent {
+  constructor(DOMString type, BackgroundFetchEventInit init);
+  Promise<undefined> updateUI(optional BackgroundFetchUIOptions options = {});
+};

package/background-sync.idl

@@ -0,0 +1,30 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Web Background Synchronization (https://wicg.github.io/background-sync/spec/)
+
+partial interface ServiceWorkerRegistration {
+  readonly attribute SyncManager sync;
+};
+
+[Exposed=(Window,Worker)]
+interface SyncManager {
+  Promise<undefined> register(DOMString tag);
+  Promise<sequence<DOMString>> getTags();
+};
+
+partial interface ServiceWorkerGlobalScope {
+  attribute EventHandler onsync;
+};
+
+[Exposed=ServiceWorker]
+interface SyncEvent : ExtendableEvent {
+  constructor(DOMString type, SyncEventInit init);
+  readonly attribute DOMString tag;
+  readonly attribute boolean lastChance;
+};
+
+dictionary SyncEventInit : ExtendableEventInit {
+  required DOMString tag;
+  boolean lastChance = false;
+};

package/badging.idl

@@ -0,0 +1,19 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Badging API (https://w3c.github.io/badging/)
+
+[SecureContext]
+partial interface Navigator {
+  Promise<undefined> setClientBadge(optional [EnforceRange] unsigned long long contents);
+  Promise<undefined> clearClientBadge();
+};
+
+[SecureContext]
+interface mixin NavigatorBadge {
+  Promise<undefined> setAppBadge(optional [EnforceRange] unsigned long long contents);
+  Promise<undefined> clearAppBadge();
+};
+
+Navigator includes NavigatorBadge;
+WorkerNavigator includes NavigatorBadge;

package/battery-status.idl

@@ -0,0 +1,21 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Battery Status API (https://w3c.github.io/battery/)
+
+[SecureContext]
+partial interface Navigator {
+  Promise<BatteryManager> getBattery();
+};
+
+[SecureContext, Exposed=Window]
+interface BatteryManager : EventTarget {
+    readonly        attribute boolean             charging;
+    readonly        attribute unrestricted double chargingTime;
+    readonly        attribute unrestricted double dischargingTime;
+    readonly        attribute double              level;
+                    attribute EventHandler        onchargingchange;
+                    attribute EventHandler        onchargingtimechange;
+                    attribute EventHandler        ondischargingtimechange;
+                    attribute EventHandler        onlevelchange;
+};

package/beacon.idl

@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Beacon (https://w3c.github.io/beacon/)
+
+partial interface Navigator {
+    boolean sendBeacon(USVString url, optional BodyInit? data = null);
+};

package/capture-handle-identity.idl

@@ -0,0 +1,27 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Capture Handle - Bootstrapping Collaboration when Screensharing (https://w3c.github.io/mediacapture-handle/identity/)
+
+dictionary CaptureHandleConfig {
+  boolean exposeOrigin = false;
+  DOMString handle = "";
+  sequence<DOMString> permittedOrigins = [];
+};
+
+partial interface MediaDevices {
+  undefined setCaptureHandleConfig(optional CaptureHandleConfig config = {});
+};
+
+dictionary CaptureHandle {
+  DOMString origin;
+  DOMString handle;
+};
+
+partial interface MediaStreamTrack {
+  CaptureHandle? getCaptureHandle();
+};
+
+partial interface MediaStreamTrack {
+  attribute EventHandler oncapturehandlechange;
+};

package/clipboard-apis.idl

@@ -0,0 +1,51 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Clipboard API and events (https://w3c.github.io/clipboard-apis/)
+
+dictionary ClipboardEventInit : EventInit {
+  DataTransfer? clipboardData = null;
+};
+
+[Exposed=Window]
+interface ClipboardEvent : Event {
+  constructor(DOMString type, optional ClipboardEventInit eventInitDict = {});
+  readonly attribute DataTransfer? clipboardData;
+};
+
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute Clipboard clipboard;
+};
+
+typedef Promise<(DOMString or Blob)> ClipboardItemData;
+
+[SecureContext, Exposed=Window]
+interface ClipboardItem {
+  constructor(record<DOMString, ClipboardItemData> items,
+              optional ClipboardItemOptions options = {});
+
+  readonly attribute PresentationStyle presentationStyle;
+  readonly attribute FrozenArray<DOMString> types;
+
+  Promise<Blob> getType(DOMString type);
+};
+
+enum PresentationStyle { "unspecified", "inline", "attachment" };
+
+dictionary ClipboardItemOptions {
+  PresentationStyle presentationStyle = "unspecified";
+};
+
+typedef sequence<ClipboardItem> ClipboardItems;
+
+[SecureContext, Exposed=Window]
+interface Clipboard : EventTarget {
+  Promise<ClipboardItems> read();
+  Promise<DOMString> readText();
+  Promise<undefined> write(ClipboardItems data);
+  Promise<undefined> writeText(DOMString data);
+};
+
+dictionary ClipboardPermissionDescriptor : PermissionDescriptor {
+  boolean allowWithoutGesture = false;
+};

package/close-watcher.idl

@@ -0,0 +1,19 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Close Watcher API (https://wicg.github.io/close-watcher/)
+
+[Exposed=Window]
+interface CloseWatcher : EventTarget {
+  constructor(optional CloseWatcherOptions options = {});
+
+  undefined destroy();
+  undefined close();
+
+  attribute EventHandler oncancel;
+  attribute EventHandler onclose;
+};
+
+dictionary CloseWatcherOptions {
+  AbortSignal signal;
+};

package/compat.idl

@@ -0,0 +1,13 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Compatibility Standard (https://compat.spec.whatwg.org/)
+
+partial interface Window {
+    readonly attribute short orientation;
+    attribute EventHandler onorientationchange;
+};
+
+partial interface HTMLBodyElement {
+    attribute EventHandler onorientationchange;
+};

package/compression.idl

@@ -0,0 +1,16 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Compression Streams (https://wicg.github.io/compression/)
+
+[Exposed=*]
+interface CompressionStream {
+  constructor(DOMString format);
+};
+CompressionStream includes GenericTransformStream;
+
+[Exposed=*]
+interface DecompressionStream {
+  constructor(DOMString format);
+};
+DecompressionStream includes GenericTransformStream;

package/compute-pressure.idl

@@ -0,0 +1,40 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Compute Pressure Level 1 (https://w3c.github.io/compute-pressure/)
+
+enum PressureState { "nominal", "fair", "serious", "critical" };
+
+enum PressureFactor { "thermal", "power-supply" };
+
+callback PressureUpdateCallback = undefined (
+  sequence<PressureRecord> changes,
+  PressureObserver observer
+);
+
+enum PressureSource { "cpu" };
+
+[Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
+interface PressureObserver {
+  constructor(PressureUpdateCallback callback, optional PressureObserverOptions options = {});
+
+  Promise<undefined> observe(PressureSource source);
+  undefined unobserve(PressureSource source);
+  undefined disconnect();
+  sequence<PressureRecord> takeRecords();
+
+  [SameObject] static readonly attribute FrozenArray<PressureSource> supportedSources;
+};
+
+[Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
+interface PressureRecord {
+  readonly attribute PressureSource source;
+  readonly attribute PressureState state;
+  readonly attribute FrozenArray<PressureFactor> factors;
+  readonly attribute DOMHighResTimeStamp time;
+  [Default] object toJSON();
+};
+
+dictionary PressureObserverOptions {
+  double sampleRate = 1.0;
+};

package/console.idl

@@ -0,0 +1,34 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Console Standard (https://console.spec.whatwg.org/)
+
+[Exposed=*]
+namespace console { // but see namespace object requirements below
+  // Logging
+  undefined assert(optional boolean condition = false, any... data);
+  undefined clear();
+  undefined debug(any... data);
+  undefined error(any... data);
+  undefined info(any... data);
+  undefined log(any... data);
+  undefined table(optional any tabularData, optional sequence<DOMString> properties);
+  undefined trace(any... data);
+  undefined warn(any... data);
+  undefined dir(optional any item, optional object? options);
+  undefined dirxml(any... data);
+
+  // Counting
+  undefined count(optional DOMString label = "default");
+  undefined countReset(optional DOMString label = "default");
+
+  // Grouping
+  undefined group(any... data);
+  undefined groupCollapsed(any... data);
+  undefined groupEnd();
+
+  // Timing
+  undefined time(optional DOMString label = "default");
+  undefined timeLog(optional DOMString label = "default", any... data);
+  undefined timeEnd(optional DOMString label = "default");
+};

package/contact-picker.idl

@@ -0,0 +1,44 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Contact Picker API (https://w3c.github.io/contact-picker/)
+
+[Exposed=Window]
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute ContactsManager contacts;
+};
+
+enum ContactProperty { "address", "email", "icon", "name", "tel" };
+
+[Exposed=Window]
+interface ContactAddress {
+  [Default] object toJSON();
+  readonly attribute DOMString city;
+  readonly attribute DOMString country;
+  readonly attribute DOMString dependentLocality;
+  readonly attribute DOMString organization;
+  readonly attribute DOMString phone;
+  readonly attribute DOMString postalCode;
+  readonly attribute DOMString recipient;
+  readonly attribute DOMString region;
+  readonly attribute DOMString sortingCode;
+  readonly attribute FrozenArray<DOMString> addressLine;
+};
+
+dictionary ContactInfo {
+    sequence<ContactAddress> address;
+    sequence<DOMString> email;
+    sequence<Blob> icon;
+    sequence<DOMString> name;
+    sequence<DOMString> tel;
+};
+
+dictionary ContactsSelectOptions {
+    boolean multiple = false;
+};
+
+[Exposed=Window,SecureContext]
+interface ContactsManager {
+    Promise<sequence<ContactProperty>> getProperties();
+    Promise<sequence<ContactInfo>> select(sequence<ContactProperty> properties, optional ContactsSelectOptions options = {});
+};

package/content-index.idl

@@ -0,0 +1,46 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Content Index (https://wicg.github.io/content-index/spec/)
+
+partial interface ServiceWorkerGlobalScope {
+  attribute EventHandler oncontentdelete;
+};
+
+partial interface ServiceWorkerRegistration {
+  [SameObject] readonly attribute ContentIndex index;
+};
+
+enum ContentCategory {
+  "",
+  "homepage",
+  "article",
+  "video",
+  "audio",
+};
+
+dictionary ContentDescription {
+  required DOMString id;
+  required DOMString title;
+  required DOMString description;
+  ContentCategory category = "";
+  sequence<ImageResource> icons = [];
+  required USVString url;
+};
+
+[Exposed=(Window,Worker)]
+interface ContentIndex {
+  Promise<undefined> add(ContentDescription description);
+  Promise<undefined> delete(DOMString id);
+  Promise<sequence<ContentDescription>> getAll();
+};
+
+dictionary ContentIndexEventInit : ExtendableEventInit {
+  required DOMString id;
+};
+
+[Exposed=ServiceWorker]
+interface ContentIndexEvent : ExtendableEvent {
+  constructor(DOMString type, ContentIndexEventInit init);
+  readonly attribute DOMString id;
+};

package/cookie-store.idl

@@ -0,0 +1,110 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Cookie Store API (https://wicg.github.io/cookie-store/)
+
+[Exposed=(ServiceWorker,Window),
+ SecureContext]
+interface CookieStore : EventTarget {
+  Promise<CookieListItem?> get(USVString name);
+  Promise<CookieListItem?> get(optional CookieStoreGetOptions options = {});
+
+  Promise<CookieList> getAll(USVString name);
+  Promise<CookieList> getAll(optional CookieStoreGetOptions options = {});
+
+  Promise<undefined> set(USVString name, USVString value);
+  Promise<undefined> set(CookieInit options);
+
+  Promise<undefined> delete(USVString name);
+  Promise<undefined> delete(CookieStoreDeleteOptions options);
+
+  [Exposed=Window]
+  attribute EventHandler onchange;
+};
+
+dictionary CookieStoreGetOptions {
+  USVString name;
+  USVString url;
+};
+
+enum CookieSameSite {
+  "strict",
+  "lax",
+  "none"
+};
+
+dictionary CookieInit {
+  required USVString name;
+  required USVString value;
+  DOMHighResTimeStamp? expires = null;
+  USVString? domain = null;
+  USVString path = "/";
+  CookieSameSite sameSite = "strict";
+};
+
+dictionary CookieStoreDeleteOptions {
+  required USVString name;
+  USVString? domain = null;
+  USVString path = "/";
+};
+
+dictionary CookieListItem {
+  USVString name;
+  USVString value;
+  USVString? domain;
+  USVString path;
+  DOMHighResTimeStamp? expires;
+  boolean secure;
+  CookieSameSite sameSite;
+};
+
+typedef sequence<CookieListItem> CookieList;
+
+[Exposed=(ServiceWorker,Window),
+ SecureContext]
+interface CookieStoreManager {
+  Promise<undefined> subscribe(sequence<CookieStoreGetOptions> subscriptions);
+  Promise<sequence<CookieStoreGetOptions>> getSubscriptions();
+  Promise<undefined> unsubscribe(sequence<CookieStoreGetOptions> subscriptions);
+};
+
+[Exposed=(ServiceWorker,Window)]
+partial interface ServiceWorkerRegistration {
+  [SameObject] readonly attribute CookieStoreManager cookies;
+};
+
+[Exposed=Window,
+ SecureContext]
+interface CookieChangeEvent : Event {
+  constructor(DOMString type, optional CookieChangeEventInit eventInitDict = {});
+  [SameObject] readonly attribute FrozenArray<CookieListItem> changed;
+  [SameObject] readonly attribute FrozenArray<CookieListItem> deleted;
+};
+
+dictionary CookieChangeEventInit : EventInit {
+  CookieList changed;
+  CookieList deleted;
+};
+
+[Exposed=ServiceWorker]
+interface ExtendableCookieChangeEvent : ExtendableEvent {
+  constructor(DOMString type, optional ExtendableCookieChangeEventInit eventInitDict = {});
+  [SameObject] readonly attribute FrozenArray<CookieListItem> changed;
+  [SameObject] readonly attribute FrozenArray<CookieListItem> deleted;
+};
+
+dictionary ExtendableCookieChangeEventInit : ExtendableEventInit {
+  CookieList changed;
+  CookieList deleted;
+};
+
+[SecureContext]
+partial interface Window {
+  [SameObject] readonly attribute CookieStore cookieStore;
+};
+
+partial interface ServiceWorkerGlobalScope {
+  [SameObject] readonly attribute CookieStore cookieStore;
+
+  attribute EventHandler oncookiechange;
+};

package/crash-reporting.idl

@@ -0,0 +1,10 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Crash Reporting (https://wicg.github.io/crash-reporting/)
+
+[Exposed=(Window,Worker)]
+interface CrashReportBody : ReportBody {
+  [Default] object toJSON();
+  readonly attribute DOMString? reason;
+};