@webref/idl 3.29.0 → 3.31.0

package/generic-sensor.idl

@@ -0,0 +1,60 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Generic Sensor API (https://w3c.github.io/sensors/)
+
+[SecureContext, Exposed=(DedicatedWorker, Window)]
+interface Sensor : EventTarget {
+  readonly attribute boolean activated;
+  readonly attribute boolean hasReading;
+  readonly attribute DOMHighResTimeStamp? timestamp;
+  undefined start();
+  undefined stop();
+  attribute EventHandler onreading;
+  attribute EventHandler onactivate;
+  attribute EventHandler onerror;
+};
+
+dictionary SensorOptions {
+  double frequency;
+};
+
+[SecureContext, Exposed=(DedicatedWorker, Window)]
+interface SensorErrorEvent : Event {
+  constructor(DOMString type, SensorErrorEventInit errorEventInitDict);
+  readonly attribute DOMException error;
+};
+
+dictionary SensorErrorEventInit : EventInit {
+  required DOMException error;
+};
+
+dictionary MockSensorConfiguration {
+  required MockSensorType mockSensorType;
+  boolean connected = true;
+  double? maxSamplingFrequency;
+  double? minSamplingFrequency;
+};
+
+dictionary MockSensor {
+  double maxSamplingFrequency;
+  double minSamplingFrequency;
+  double requestedSamplingFrequency;
+};
+
+enum MockSensorType {
+  "ambient-light",
+  "accelerometer",
+  "linear-acceleration",
+  "gravity",
+  "gyroscope",
+  "magnetometer",
+  "uncalibrated-magnetometer",
+  "absolute-orientation",
+  "relative-orientation",
+  "geolocation",
+  "proximity",
+};
+
+dictionary MockSensorReadingValues {
+};

package/geolocation-sensor.idl

@@ -0,0 +1,47 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Geolocation Sensor (https://w3c.github.io/geolocation-sensor/)
+
+[SecureContext,
+ Exposed=(DedicatedWorker, Window)]
+interface GeolocationSensor : Sensor {
+  constructor(optional GeolocationSensorOptions options = {});
+  static Promise<GeolocationSensorReading> read(optional ReadOptions readOptions = {});
+  readonly attribute unrestricted double? latitude;
+  readonly attribute unrestricted double? longitude;
+  readonly attribute unrestricted double? altitude;
+  readonly attribute unrestricted double? accuracy;
+  readonly attribute unrestricted double? altitudeAccuracy;
+  readonly attribute unrestricted double? heading;
+  readonly attribute unrestricted double? speed;
+};
+
+dictionary GeolocationSensorOptions : SensorOptions {
+  // placeholder for GeolocationSensor-specific options
+};
+
+dictionary ReadOptions : GeolocationSensorOptions {
+  AbortSignal? signal;
+};
+
+dictionary GeolocationSensorReading {
+  DOMHighResTimeStamp? timestamp;
+  double? latitude;
+  double? longitude;
+  double? altitude;
+  double? accuracy;
+  double? altitudeAccuracy;
+  double? heading;
+  double? speed;
+};
+
+dictionary GeolocationReadingValues {
+  required double? latitude;
+  required double? longitude;
+  required double? altitude;
+  required double? accuracy;
+  required double? altitudeAccuracy;
+  required double? heading;
+  required double? speed;
+};

package/geolocation.idl

@@ -0,0 +1,65 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Geolocation API (https://w3c.github.io/geolocation-api/)
+
+partial interface Navigator {
+  [SameObject] readonly attribute Geolocation geolocation;
+};
+
+[Exposed=Window]
+interface Geolocation {
+  undefined getCurrentPosition (
+    PositionCallback successCallback,
+    optional PositionErrorCallback? errorCallback = null,
+    optional PositionOptions options = {}
+  );
+
+  long watchPosition (
+    PositionCallback successCallback,
+    optional PositionErrorCallback? errorCallback = null,
+    optional PositionOptions options = {}
+  );
+
+  undefined clearWatch (long watchId);
+};
+
+callback PositionCallback = undefined (
+  GeolocationPosition position
+);
+
+callback PositionErrorCallback = undefined (
+  GeolocationPositionError positionError
+);
+
+dictionary PositionOptions {
+  boolean enableHighAccuracy = false;
+  [Clamp] unsigned long timeout = 0xFFFFFFFF;
+  [Clamp] unsigned long maximumAge = 0;
+};
+
+[Exposed=Window, SecureContext]
+interface GeolocationPosition {
+  readonly attribute GeolocationCoordinates coords;
+  readonly attribute EpochTimeStamp timestamp;
+};
+
+[Exposed=Window, SecureContext]
+interface GeolocationCoordinates {
+  readonly attribute double accuracy;
+  readonly attribute double latitude;
+  readonly attribute double longitude;
+  readonly attribute double? altitude;
+  readonly attribute double? altitudeAccuracy;
+  readonly attribute double? heading;
+  readonly attribute double? speed;
+};
+
+[Exposed=Window]
+interface GeolocationPositionError {
+  const unsigned short PERMISSION_DENIED = 1;
+  const unsigned short POSITION_UNAVAILABLE = 2;
+  const unsigned short TIMEOUT = 3;
+  readonly attribute unsigned short code;
+  readonly attribute DOMString message;
+};

package/geometry.idl

@@ -0,0 +1,290 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Geometry Interfaces Module Level 1 (https://drafts.fxtf.org/geometry-1/)
+
+[Exposed=(Window,Worker),
+ Serializable]
+interface DOMPointReadOnly {
+    constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+            optional unrestricted double z = 0, optional unrestricted double w = 1);
+
+    [NewObject] static DOMPointReadOnly fromPoint(optional DOMPointInit other = {});
+
+    readonly attribute unrestricted double x;
+    readonly attribute unrestricted double y;
+    readonly attribute unrestricted double z;
+    readonly attribute unrestricted double w;
+
+    [NewObject] DOMPoint matrixTransform(optional DOMMatrixInit matrix = {});
+
+    [Default] object toJSON();
+};
+
+[Exposed=(Window,Worker),
+ Serializable,
+ LegacyWindowAlias=SVGPoint]
+interface DOMPoint : DOMPointReadOnly {
+    constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+            optional unrestricted double z = 0, optional unrestricted double w = 1);
+
+    [NewObject] static DOMPoint fromPoint(optional DOMPointInit other = {});
+
+    inherit attribute unrestricted double x;
+    inherit attribute unrestricted double y;
+    inherit attribute unrestricted double z;
+    inherit attribute unrestricted double w;
+};
+
+dictionary DOMPointInit {
+    unrestricted double x = 0;
+    unrestricted double y = 0;
+    unrestricted double z = 0;
+    unrestricted double w = 1;
+};
+
+[Exposed=(Window,Worker),
+ Serializable]
+interface DOMRectReadOnly {
+    constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+            optional unrestricted double width = 0, optional unrestricted double height = 0);
+
+    [NewObject] static DOMRectReadOnly fromRect(optional DOMRectInit other = {});
+
+    readonly attribute unrestricted double x;
+    readonly attribute unrestricted double y;
+    readonly attribute unrestricted double width;
+    readonly attribute unrestricted double height;
+    readonly attribute unrestricted double top;
+    readonly attribute unrestricted double right;
+    readonly attribute unrestricted double bottom;
+    readonly attribute unrestricted double left;
+
+    [Default] object toJSON();
+};
+
+[Exposed=(Window,Worker),
+ Serializable,
+ LegacyWindowAlias=SVGRect]
+interface DOMRect : DOMRectReadOnly {
+    constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+            optional unrestricted double width = 0, optional unrestricted double height = 0);
+
+    [NewObject] static DOMRect fromRect(optional DOMRectInit other = {});
+
+    inherit attribute unrestricted double x;
+    inherit attribute unrestricted double y;
+    inherit attribute unrestricted double width;
+    inherit attribute unrestricted double height;
+};
+
+dictionary DOMRectInit {
+    unrestricted double x = 0;
+    unrestricted double y = 0;
+    unrestricted double width = 0;
+    unrestricted double height = 0;
+};
+
+[Exposed=Window]
+interface DOMRectList {
+    readonly attribute unsigned long length;
+    getter DOMRect? item(unsigned long index);
+};
+
+[Exposed=(Window,Worker),
+ Serializable]
+interface DOMQuad {
+    constructor(optional DOMPointInit p1 = {}, optional DOMPointInit p2 = {},
+            optional DOMPointInit p3 = {}, optional DOMPointInit p4 = {});
+
+    [NewObject] static DOMQuad fromRect(optional DOMRectInit other = {});
+    [NewObject] static DOMQuad fromQuad(optional DOMQuadInit other = {});
+
+    [SameObject] readonly attribute DOMPoint p1;
+    [SameObject] readonly attribute DOMPoint p2;
+    [SameObject] readonly attribute DOMPoint p3;
+    [SameObject] readonly attribute DOMPoint p4;
+    [NewObject] DOMRect getBounds();
+
+    [Default] object toJSON();
+};
+
+dictionary DOMQuadInit {
+  DOMPointInit p1;
+  DOMPointInit p2;
+  DOMPointInit p3;
+  DOMPointInit p4;
+};
+
+[Exposed=(Window,Worker),
+ Serializable]
+interface DOMMatrixReadOnly {
+    constructor(optional (DOMString or sequence<unrestricted double>) init);
+
+    [NewObject] static DOMMatrixReadOnly fromMatrix(optional DOMMatrixInit other = {});
+    [NewObject] static DOMMatrixReadOnly fromFloat32Array(Float32Array array32);
+    [NewObject] static DOMMatrixReadOnly fromFloat64Array(Float64Array array64);
+
+    // These attributes are simple aliases for certain elements of the 4x4 matrix
+    readonly attribute unrestricted double a;
+    readonly attribute unrestricted double b;
+    readonly attribute unrestricted double c;
+    readonly attribute unrestricted double d;
+    readonly attribute unrestricted double e;
+    readonly attribute unrestricted double f;
+
+    readonly attribute unrestricted double m11;
+    readonly attribute unrestricted double m12;
+    readonly attribute unrestricted double m13;
+    readonly attribute unrestricted double m14;
+    readonly attribute unrestricted double m21;
+    readonly attribute unrestricted double m22;
+    readonly attribute unrestricted double m23;
+    readonly attribute unrestricted double m24;
+    readonly attribute unrestricted double m31;
+    readonly attribute unrestricted double m32;
+    readonly attribute unrestricted double m33;
+    readonly attribute unrestricted double m34;
+    readonly attribute unrestricted double m41;
+    readonly attribute unrestricted double m42;
+    readonly attribute unrestricted double m43;
+    readonly attribute unrestricted double m44;
+
+    readonly attribute boolean is2D;
+    readonly attribute boolean isIdentity;
+
+    // Immutable transform methods
+    [NewObject] DOMMatrix translate(optional unrestricted double tx = 0,
+                                    optional unrestricted double ty = 0,
+                                    optional unrestricted double tz = 0);
+    [NewObject] DOMMatrix scale(optional unrestricted double scaleX = 1,
+                                optional unrestricted double scaleY,
+                                optional unrestricted double scaleZ = 1,
+                                optional unrestricted double originX = 0,
+                                optional unrestricted double originY = 0,
+                                optional unrestricted double originZ = 0);
+    [NewObject] DOMMatrix scaleNonUniform(optional unrestricted double scaleX = 1,
+                                          optional unrestricted double scaleY = 1);
+    [NewObject] DOMMatrix scale3d(optional unrestricted double scale = 1,
+                                  optional unrestricted double originX = 0,
+                                  optional unrestricted double originY = 0,
+                                  optional unrestricted double originZ = 0);
+    [NewObject] DOMMatrix rotate(optional unrestricted double rotX = 0,
+                                 optional unrestricted double rotY,
+                                 optional unrestricted double rotZ);
+    [NewObject] DOMMatrix rotateFromVector(optional unrestricted double x = 0,
+                                           optional unrestricted double y = 0);
+    [NewObject] DOMMatrix rotateAxisAngle(optional unrestricted double x = 0,
+                                          optional unrestricted double y = 0,
+                                          optional unrestricted double z = 0,
+                                          optional unrestricted double angle = 0);
+    [NewObject] DOMMatrix skewX(optional unrestricted double sx = 0);
+    [NewObject] DOMMatrix skewY(optional unrestricted double sy = 0);
+    [NewObject] DOMMatrix multiply(optional DOMMatrixInit other = {});
+    [NewObject] DOMMatrix flipX();
+    [NewObject] DOMMatrix flipY();
+    [NewObject] DOMMatrix inverse();
+
+    [NewObject] DOMPoint transformPoint(optional DOMPointInit point = {});
+    [NewObject] Float32Array toFloat32Array();
+    [NewObject] Float64Array toFloat64Array();
+
+    [Exposed=Window] stringifier;
+    [Default] object toJSON();
+};
+
+[Exposed=(Window,Worker),
+ Serializable,
+ LegacyWindowAlias=(SVGMatrix,WebKitCSSMatrix)]
+interface DOMMatrix : DOMMatrixReadOnly {
+    constructor(optional (DOMString or sequence<unrestricted double>) init);
+
+    [NewObject] static DOMMatrix fromMatrix(optional DOMMatrixInit other = {});
+    [NewObject] static DOMMatrix fromFloat32Array(Float32Array array32);
+    [NewObject] static DOMMatrix fromFloat64Array(Float64Array array64);
+
+    // These attributes are simple aliases for certain elements of the 4x4 matrix
+    inherit attribute unrestricted double a;
+    inherit attribute unrestricted double b;
+    inherit attribute unrestricted double c;
+    inherit attribute unrestricted double d;
+    inherit attribute unrestricted double e;
+    inherit attribute unrestricted double f;
+
+    inherit attribute unrestricted double m11;
+    inherit attribute unrestricted double m12;
+    inherit attribute unrestricted double m13;
+    inherit attribute unrestricted double m14;
+    inherit attribute unrestricted double m21;
+    inherit attribute unrestricted double m22;
+    inherit attribute unrestricted double m23;
+    inherit attribute unrestricted double m24;
+    inherit attribute unrestricted double m31;
+    inherit attribute unrestricted double m32;
+    inherit attribute unrestricted double m33;
+    inherit attribute unrestricted double m34;
+    inherit attribute unrestricted double m41;
+    inherit attribute unrestricted double m42;
+    inherit attribute unrestricted double m43;
+    inherit attribute unrestricted double m44;
+
+    // Mutable transform methods
+    DOMMatrix multiplySelf(optional DOMMatrixInit other = {});
+    DOMMatrix preMultiplySelf(optional DOMMatrixInit other = {});
+    DOMMatrix translateSelf(optional unrestricted double tx = 0,
+                            optional unrestricted double ty = 0,
+                            optional unrestricted double tz = 0);
+    DOMMatrix scaleSelf(optional unrestricted double scaleX = 1,
+                        optional unrestricted double scaleY,
+                        optional unrestricted double scaleZ = 1,
+                        optional unrestricted double originX = 0,
+                        optional unrestricted double originY = 0,
+                        optional unrestricted double originZ = 0);
+    DOMMatrix scale3dSelf(optional unrestricted double scale = 1,
+                          optional unrestricted double originX = 0,
+                          optional unrestricted double originY = 0,
+                          optional unrestricted double originZ = 0);
+    DOMMatrix rotateSelf(optional unrestricted double rotX = 0,
+                         optional unrestricted double rotY,
+                         optional unrestricted double rotZ);
+    DOMMatrix rotateFromVectorSelf(optional unrestricted double x = 0,
+                                   optional unrestricted double y = 0);
+    DOMMatrix rotateAxisAngleSelf(optional unrestricted double x = 0,
+                                  optional unrestricted double y = 0,
+                                  optional unrestricted double z = 0,
+                                  optional unrestricted double angle = 0);
+    DOMMatrix skewXSelf(optional unrestricted double sx = 0);
+    DOMMatrix skewYSelf(optional unrestricted double sy = 0);
+    DOMMatrix invertSelf();
+
+    [Exposed=Window] DOMMatrix setMatrixValue(DOMString transformList);
+};
+
+dictionary DOMMatrix2DInit {
+    unrestricted double a;
+    unrestricted double b;
+    unrestricted double c;
+    unrestricted double d;
+    unrestricted double e;
+    unrestricted double f;
+    unrestricted double m11;
+    unrestricted double m12;
+    unrestricted double m21;
+    unrestricted double m22;
+    unrestricted double m41;
+    unrestricted double m42;
+};
+
+dictionary DOMMatrixInit : DOMMatrix2DInit {
+    unrestricted double m13 = 0;
+    unrestricted double m14 = 0;
+    unrestricted double m23 = 0;
+    unrestricted double m24 = 0;
+    unrestricted double m31 = 0;
+    unrestricted double m32 = 0;
+    unrestricted double m33 = 1;
+    unrestricted double m34 = 0;
+    unrestricted double m43 = 0;
+    unrestricted double m44 = 1;
+    boolean is2D;
+};

package/get-installed-related-apps.idl

@@ -0,0 +1,16 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Get Installed Related Apps API (https://wicg.github.io/get-installed-related-apps/spec/)
+
+dictionary RelatedApplication {
+    required USVString platform;
+    USVString url;
+    DOMString id;
+    USVString version;
+};
+
+[Exposed=Window]
+partial interface Navigator {
+  [SecureContext] Promise<sequence<RelatedApplication>> getInstalledRelatedApps();
+};

package/gpc-spec.idl

@@ -0,0 +1,10 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Global Privacy Control (GPC) (https://privacycg.github.io/gpc-spec/)
+
+interface mixin GlobalPrivacyControl {
+  readonly attribute boolean globalPrivacyControl;
+};
+Navigator includes GlobalPrivacyControl;
+WorkerNavigator includes GlobalPrivacyControl;

package/gyroscope.idl

@@ -0,0 +1,24 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Gyroscope (https://w3c.github.io/gyroscope/)
+
+[SecureContext, Exposed=Window]
+interface Gyroscope : Sensor {
+  constructor(optional GyroscopeSensorOptions sensorOptions = {});
+  readonly attribute double? x;
+  readonly attribute double? y;
+  readonly attribute double? z;
+};
+
+enum GyroscopeLocalCoordinateSystem { "device", "screen" };
+
+dictionary GyroscopeSensorOptions : SensorOptions {
+  GyroscopeLocalCoordinateSystem referenceFrame = "device";
+};
+
+dictionary GyroscopeReadingValues {
+  required double? x;
+  required double? y;
+  required double? z;
+};

package/hr-time.idl

@@ -0,0 +1,19 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: High Resolution Time (https://w3c.github.io/hr-time/)
+
+typedef double DOMHighResTimeStamp;
+
+typedef unsigned long long EpochTimeStamp;
+
+[Exposed=(Window,Worker)]
+interface Performance : EventTarget {
+    DOMHighResTimeStamp now();
+    readonly attribute DOMHighResTimeStamp timeOrigin;
+    [Default] object toJSON();
+};
+
+partial interface mixin WindowOrWorkerGlobalScope {
+  [Replaceable] readonly attribute Performance performance;
+};

package/html-media-capture.idl

@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: HTML Media Capture (https://w3c.github.io/html-media-capture/)
+
+partial interface HTMLInputElement {
+    [CEReactions] attribute DOMString capture;
+};