@webref/idl 3.29.0 → 3.30.0

package/payment-request.idl

@@ -0,0 +1,112 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Payment Request API 1.1 (https://w3c.github.io/payment-request/)
+
+[SecureContext, Exposed=Window]
+interface PaymentRequest : EventTarget {
+  constructor(
+    sequence<PaymentMethodData> methodData,
+    PaymentDetailsInit details
+  );
+  [NewObject]
+  Promise<PaymentResponse> show(optional Promise<PaymentDetailsUpdate> detailsPromise);
+  [NewObject]
+  Promise<undefined> abort();
+  [NewObject]
+  Promise<boolean> canMakePayment();
+
+  readonly attribute DOMString id;
+
+  attribute EventHandler onpaymentmethodchange;
+};
+
+dictionary PaymentMethodData {
+  required DOMString supportedMethods;
+  object data;
+};
+
+dictionary PaymentCurrencyAmount {
+  required DOMString currency;
+  required DOMString value;
+};
+
+dictionary PaymentDetailsBase {
+  sequence<PaymentItem> displayItems;
+  sequence<PaymentDetailsModifier> modifiers;
+};
+
+dictionary PaymentDetailsInit : PaymentDetailsBase {
+  DOMString id;
+  required PaymentItem total;
+};
+
+dictionary PaymentDetailsUpdate : PaymentDetailsBase {
+  PaymentItem total;
+  object paymentMethodErrors;
+};
+
+dictionary PaymentDetailsModifier {
+  required DOMString supportedMethods;
+  PaymentItem total;
+  sequence<PaymentItem> additionalDisplayItems;
+  object data;
+};
+
+dictionary PaymentItem {
+  required DOMString label;
+  required PaymentCurrencyAmount amount;
+  boolean pending = false;
+};
+
+dictionary PaymentCompleteDetails {
+  object? data = null;
+};
+
+enum PaymentComplete {
+  "fail",
+  "success",
+  "unknown"
+};
+
+[SecureContext, Exposed=Window]
+interface PaymentResponse : EventTarget  {
+  [Default] object toJSON();
+
+  readonly attribute DOMString requestId;
+  readonly attribute DOMString methodName;
+  readonly attribute object details;
+
+  [NewObject]
+  Promise<undefined> complete(
+    optional PaymentComplete result = "unknown",
+    optional PaymentCompleteDetails details = {}
+  );
+  [NewObject]
+  Promise<undefined> retry(optional PaymentValidationErrors errorFields = {});
+};
+
+dictionary PaymentValidationErrors {
+  DOMString error;
+  object paymentMethod;
+};
+
+[SecureContext, Exposed=Window]
+interface PaymentMethodChangeEvent : PaymentRequestUpdateEvent {
+  constructor(DOMString type, optional PaymentMethodChangeEventInit eventInitDict = {});
+  readonly attribute DOMString methodName;
+  readonly attribute object? methodDetails;
+};
+
+dictionary PaymentMethodChangeEventInit : PaymentRequestUpdateEventInit {
+  DOMString methodName = "";
+  object? methodDetails = null;
+};
+
+[SecureContext, Exposed=Window]
+interface PaymentRequestUpdateEvent : Event {
+  constructor(DOMString type, optional PaymentRequestUpdateEventInit eventInitDict = {});
+  undefined updateWith(Promise<PaymentDetailsUpdate> detailsPromise);
+};
+
+dictionary PaymentRequestUpdateEventInit : EventInit {};

package/performance-measure-memory.idl

@@ -0,0 +1,30 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Measure Memory API (https://wicg.github.io/performance-measure-memory/)
+
+dictionary MemoryMeasurement {
+  unsigned long long bytes;
+  sequence<MemoryBreakdownEntry> breakdown;
+};
+
+dictionary MemoryBreakdownEntry {
+  unsigned long long bytes;
+  sequence<MemoryAttribution> attribution;
+  sequence<DOMString> types;
+};
+
+dictionary MemoryAttribution {
+  USVString url;
+  MemoryAttributionContainer container;
+  DOMString scope;
+};
+
+dictionary MemoryAttributionContainer {
+  DOMString id;
+  USVString src;
+};
+
+partial interface Performance {
+  [Exposed=(Window,ServiceWorker,SharedWorker), CrossOriginIsolated] Promise<MemoryMeasurement> measureUserAgentSpecificMemory();
+};

package/performance-timeline.idl

@@ -0,0 +1,49 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Performance Timeline (https://w3c.github.io/performance-timeline/)
+
+partial interface Performance {
+  PerformanceEntryList getEntries ();
+  PerformanceEntryList getEntriesByType (DOMString type);
+  PerformanceEntryList getEntriesByName (DOMString name, optional DOMString type);
+};
+typedef sequence<PerformanceEntry> PerformanceEntryList;
+
+[Exposed=(Window,Worker)]
+interface PerformanceEntry {
+  readonly    attribute DOMString           name;
+  readonly    attribute DOMString           entryType;
+  readonly    attribute DOMHighResTimeStamp startTime;
+  readonly    attribute DOMHighResTimeStamp duration;
+  [Default] object toJSON();
+};
+
+callback PerformanceObserverCallback = undefined (PerformanceObserverEntryList entries,
+                                             PerformanceObserver observer,
+                                             optional PerformanceObserverCallbackOptions options = {});
+[Exposed=(Window,Worker)]
+interface PerformanceObserver {
+  constructor(PerformanceObserverCallback callback);
+  undefined observe (optional PerformanceObserverInit options = {});
+  undefined disconnect ();
+  PerformanceEntryList takeRecords();
+  [SameObject] static readonly attribute FrozenArray<DOMString> supportedEntryTypes;
+};
+
+dictionary PerformanceObserverCallbackOptions {
+  unsigned long long droppedEntriesCount;
+};
+
+dictionary PerformanceObserverInit {
+  sequence<DOMString> entryTypes;
+  DOMString type;
+  boolean buffered;
+};
+
+[Exposed=(Window,Worker)]
+interface PerformanceObserverEntryList {
+  PerformanceEntryList getEntries();
+  PerformanceEntryList getEntriesByType (DOMString type);
+  PerformanceEntryList getEntriesByName (DOMString name, optional DOMString type);
+};

package/periodic-background-sync.idl

@@ -0,0 +1,34 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Web Periodic Background Synchronization (https://wicg.github.io/periodic-background-sync/)
+
+partial interface ServiceWorkerGlobalScope {
+    attribute EventHandler onperiodicsync;
+};
+
+[Exposed=(Window,Worker)]
+partial interface ServiceWorkerRegistration {
+  readonly attribute PeriodicSyncManager periodicSync;
+};
+
+[Exposed=(Window,Worker)]
+interface PeriodicSyncManager {
+    Promise<undefined> register(DOMString tag, optional BackgroundSyncOptions options = {});
+    Promise<sequence<DOMString>> getTags();
+    Promise<undefined> unregister(DOMString tag);
+};
+
+dictionary BackgroundSyncOptions {
+    [EnforceRange] unsigned long long minInterval = 0;
+};
+
+dictionary PeriodicSyncEventInit : ExtendableEventInit {
+    required DOMString tag;
+};
+
+[Exposed=ServiceWorker]
+interface PeriodicSyncEvent : ExtendableEvent {
+    constructor(DOMString type, PeriodicSyncEventInit init);
+    readonly attribute DOMString tag;
+};

package/permissions-policy.idl

@@ -0,0 +1,29 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Permissions Policy (https://w3c.github.io/webappsec-permissions-policy/)
+
+[Exposed=Window]
+interface PermissionsPolicy {
+  boolean allowsFeature(DOMString feature, optional DOMString origin);
+  sequence<DOMString> features();
+  sequence<DOMString> allowedFeatures();
+  sequence<DOMString> getAllowlistForFeature(DOMString feature);
+};
+
+partial interface Document {
+    [SameObject] readonly attribute PermissionsPolicy permissionsPolicy;
+};
+
+partial interface HTMLIFrameElement {
+    [SameObject] readonly attribute PermissionsPolicy permissionsPolicy;
+};
+
+[Exposed=Window]
+interface PermissionsPolicyViolationReportBody : ReportBody {
+  readonly attribute DOMString featureId;
+  readonly attribute DOMString? sourceFile;
+  readonly attribute long? lineNumber;
+  readonly attribute long? columnNumber;
+  readonly attribute DOMString disposition;
+};

package/permissions-request.idl

@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Requesting Permissions (https://wicg.github.io/permissions-request/)
+
+partial interface Permissions {
+  Promise<PermissionStatus> request(object permissionDesc);
+};

package/permissions-revoke.idl

@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Relinquishing Permissions (https://wicg.github.io/permissions-revoke/)
+
+partial interface Permissions {
+  Promise<PermissionStatus> revoke(object permissionDesc);
+};

package/permissions.idl

@@ -0,0 +1,41 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Permissions (https://w3c.github.io/permissions/)
+
+[Exposed=(Window)]
+partial interface Navigator {
+  [SameObject] readonly attribute Permissions permissions;
+};
+
+[Exposed=(Worker)]
+partial interface WorkerNavigator {
+  [SameObject] readonly attribute Permissions permissions;
+};
+
+[Exposed=(Window,Worker)]
+interface Permissions {
+  Promise<PermissionStatus> query(object permissionDesc);
+};
+
+dictionary PermissionDescriptor {
+  required DOMString name;
+};
+
+[Exposed=(Window,Worker)]
+interface PermissionStatus : EventTarget {
+  readonly attribute PermissionState state;
+  readonly attribute DOMString name;
+  attribute EventHandler onchange;
+};
+
+enum PermissionState {
+  "granted",
+  "denied",
+  "prompt",
+};
+
+dictionary PermissionSetParameters {
+  required PermissionDescriptor descriptor;
+  required PermissionState state;
+};

package/picture-in-picture.idl

@@ -0,0 +1,41 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Picture-in-Picture (https://w3c.github.io/picture-in-picture/)
+
+partial interface HTMLVideoElement {
+  [NewObject] Promise<PictureInPictureWindow> requestPictureInPicture();
+
+  attribute EventHandler onenterpictureinpicture;
+  attribute EventHandler onleavepictureinpicture;
+
+  [CEReactions] attribute boolean disablePictureInPicture;
+};
+
+partial interface Document {
+  readonly attribute boolean pictureInPictureEnabled;
+
+  [NewObject] Promise<undefined> exitPictureInPicture();
+};
+
+partial interface mixin DocumentOrShadowRoot {
+  readonly attribute Element? pictureInPictureElement;
+};
+
+[Exposed=Window]
+interface PictureInPictureWindow : EventTarget {
+  readonly attribute long width;
+  readonly attribute long height;
+
+  attribute EventHandler onresize;
+};
+
+[Exposed=Window]
+interface PictureInPictureEvent : Event {
+    constructor(DOMString type, PictureInPictureEventInit eventInitDict);
+    [SameObject] readonly attribute PictureInPictureWindow pictureInPictureWindow;
+};
+
+dictionary PictureInPictureEventInit : EventInit {
+    required PictureInPictureWindow pictureInPictureWindow;
+};

package/pointerevents.idl

@@ -0,0 +1,64 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Pointer Events (https://w3c.github.io/pointerevents/)
+
+dictionary PointerEventInit : MouseEventInit {
+    long        pointerId = 0;
+    double      width = 1;
+    double      height = 1;
+    float       pressure = 0;
+    float       tangentialPressure = 0;
+    long        tiltX;
+    long        tiltY;
+    long        twist = 0;
+    double      altitudeAngle;
+    double      azimuthAngle;
+    DOMString   pointerType = "";
+    boolean     isPrimary = false;
+    sequence<PointerEvent> coalescedEvents = [];
+    sequence<PointerEvent> predictedEvents = [];
+};
+
+[Exposed=Window]
+interface PointerEvent : MouseEvent {
+    constructor(DOMString type, optional PointerEventInit eventInitDict = {});
+    readonly        attribute long        pointerId;
+    readonly        attribute double      width;
+    readonly        attribute double      height;
+    readonly        attribute float       pressure;
+    readonly        attribute float       tangentialPressure;
+    readonly        attribute long        tiltX;
+    readonly        attribute long        tiltY;
+    readonly        attribute long        twist;
+    readonly        attribute double      altitudeAngle;
+    readonly        attribute double      azimuthAngle;
+    readonly        attribute DOMString   pointerType;
+    readonly        attribute boolean     isPrimary;
+    [SecureContext] sequence<PointerEvent> getCoalescedEvents();
+    sequence<PointerEvent> getPredictedEvents();
+};
+
+partial interface Element {
+  undefined setPointerCapture (long pointerId);
+  undefined releasePointerCapture (long pointerId);
+  boolean hasPointerCapture (long pointerId);
+};
+
+partial interface mixin GlobalEventHandlers {
+    attribute EventHandler onpointerover;
+    attribute EventHandler onpointerenter;
+    attribute EventHandler onpointerdown;
+    attribute EventHandler onpointermove;
+    [SecureContext] attribute EventHandler onpointerrawupdate;
+    attribute EventHandler onpointerup;
+    attribute EventHandler onpointercancel;
+    attribute EventHandler onpointerout;
+    attribute EventHandler onpointerleave;
+    attribute EventHandler ongotpointercapture;
+    attribute EventHandler onlostpointercapture;
+};
+
+partial interface Navigator {
+    readonly  attribute long maxTouchPoints;
+};

package/pointerlock.idl

@@ -0,0 +1,28 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Pointer Lock 2.0 (https://w3c.github.io/pointerlock/)
+
+partial interface Element {
+  undefined requestPointerLock();
+};
+
+partial interface Document {
+  attribute EventHandler onpointerlockchange;
+  attribute EventHandler onpointerlockerror;
+  undefined exitPointerLock();
+};
+
+partial interface mixin DocumentOrShadowRoot {
+  readonly attribute Element ? pointerLockElement;
+};
+
+partial interface MouseEvent {
+  readonly attribute double movementX;
+  readonly attribute double movementY;
+};
+
+partial dictionary MouseEventInit {
+  double movementX = 0;
+  double movementY = 0;
+};

package/portals.idl

@@ -0,0 +1,50 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Portals (https://wicg.github.io/portals/)
+
+[Exposed=Window]
+interface HTMLPortalElement : HTMLElement {
+    [HTMLConstructor] constructor();
+
+    [CEReactions] attribute USVString src;
+    [CEReactions] attribute DOMString referrerPolicy;
+
+    [NewObject] Promise<undefined> activate(optional PortalActivateOptions options = {});
+    undefined postMessage(any message, optional StructuredSerializeOptions options = {});
+
+    attribute EventHandler onmessage;
+    attribute EventHandler onmessageerror;
+};
+
+dictionary PortalActivateOptions : StructuredSerializeOptions {
+    any data;
+};
+
+partial interface Window {
+    readonly attribute PortalHost? portalHost;
+};
+
+[Exposed=Window]
+interface PortalHost : EventTarget {
+    undefined postMessage(any message, optional StructuredSerializeOptions options = {});
+
+    attribute EventHandler onmessage;
+    attribute EventHandler onmessageerror;
+};
+
+[Exposed=Window]
+interface PortalActivateEvent : Event {
+    constructor(DOMString type, optional PortalActivateEventInit eventInitDict = {});
+
+    readonly attribute any data;
+    HTMLPortalElement adoptPredecessor();
+};
+
+dictionary PortalActivateEventInit : EventInit {
+    any data = null;
+};
+
+partial interface mixin WindowEventHandlers {
+    attribute EventHandler onportalactivate;
+};

package/prefer-current-tab.idl

@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: preferCurrentTab (https://wicg.github.io/prefer-current-tab/)
+
+partial dictionary MediaStreamConstraints {
+  boolean preferCurrentTab = false;
+};

package/prerendering-revamped.idl

@@ -0,0 +1,15 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Prerendering Revamped (https://wicg.github.io/nav-speculation/prerendering.html)
+
+partial interface Document {
+    readonly attribute boolean prerendering;
+
+    // Under "special event handler IDL attributes that only apply to Document objects"
+    attribute EventHandler onprerenderingchange;
+};
+
+partial interface PerformanceNavigationTiming {
+    readonly attribute DOMHighResTimeStamp activationStart;
+};

package/presentation-api.idl

@@ -0,0 +1,95 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Presentation API (https://w3c.github.io/presentation-api/)
+
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute Presentation presentation;
+};
+
+[SecureContext, Exposed=Window]
+interface Presentation {
+};
+
+partial interface Presentation {
+  attribute PresentationRequest? defaultRequest;
+};
+
+partial interface Presentation {
+  readonly attribute PresentationReceiver? receiver;
+};
+
+[SecureContext, Exposed=Window]
+interface PresentationRequest : EventTarget {
+  constructor(USVString url);
+  constructor(sequence<USVString> urls);
+  Promise<PresentationConnection> start();
+  Promise<PresentationConnection> reconnect(USVString presentationId);
+  Promise<PresentationAvailability> getAvailability();
+
+  attribute EventHandler onconnectionavailable;
+};
+
+[SecureContext, Exposed=Window]
+interface PresentationAvailability : EventTarget {
+  readonly attribute boolean value;
+
+  attribute EventHandler onchange;
+};
+
+[SecureContext, Exposed=Window]
+interface PresentationConnectionAvailableEvent : Event {
+  constructor(DOMString type, PresentationConnectionAvailableEventInit eventInitDict);
+  [SameObject] readonly attribute PresentationConnection connection;
+};
+
+dictionary PresentationConnectionAvailableEventInit : EventInit {
+  required PresentationConnection connection;
+};
+
+enum PresentationConnectionState { "connecting", "connected", "closed", "terminated" };
+
+[SecureContext, Exposed=Window]
+interface PresentationConnection : EventTarget {
+  readonly attribute USVString id;
+  readonly attribute USVString url;
+  readonly attribute PresentationConnectionState state;
+  undefined close();
+  undefined terminate();
+  attribute EventHandler onconnect;
+  attribute EventHandler onclose;
+  attribute EventHandler onterminate;
+
+  // Communication
+  attribute BinaryType binaryType;
+  attribute EventHandler onmessage;
+  undefined send (DOMString message);
+  undefined send (Blob data);
+  undefined send (ArrayBuffer data);
+  undefined send (ArrayBufferView data);
+};
+
+enum PresentationConnectionCloseReason { "error", "closed", "wentaway" };
+
+[SecureContext, Exposed=Window]
+interface PresentationConnectionCloseEvent : Event {
+  constructor(DOMString type, PresentationConnectionCloseEventInit eventInitDict);
+  readonly attribute PresentationConnectionCloseReason reason;
+  readonly attribute DOMString message;
+};
+
+dictionary PresentationConnectionCloseEventInit : EventInit {
+  required PresentationConnectionCloseReason reason;
+  DOMString message = "";
+};
+
+[SecureContext, Exposed=Window]
+interface PresentationReceiver {
+  readonly attribute Promise<PresentationConnectionList> connectionList;
+};
+
+[SecureContext, Exposed=Window]
+interface PresentationConnectionList : EventTarget {
+  readonly attribute FrozenArray<PresentationConnection> connections;
+  attribute EventHandler onconnectionavailable;
+};

package/private-click-measurement.idl

@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Private Click Measurement (https://privacycg.github.io/private-click-measurement/)
+
+partial interface HTMLAnchorElement {
+    [CEReactions] attribute unsigned long attributionSourceId;
+};

package/proximity.idl

@@ -0,0 +1,18 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Proximity Sensor (https://w3c.github.io/proximity/)
+
+[SecureContext, Exposed=Window]
+interface ProximitySensor : Sensor {
+  constructor(optional SensorOptions sensorOptions = {});
+  readonly attribute double? distance;
+  readonly attribute double? max;
+  readonly attribute boolean? near;
+};
+
+dictionary ProximityReadingValues {
+  required double? distance;
+  required double? max;
+  required boolean? near;
+};