@webref/idl 3.41.3 → 3.42.1

package/FedCM.idl

@@ -18,11 +18,20 @@ partial interface Navigator {
   [SecureContext] readonly attribute NavigatorLogin login;
 };
 
+dictionary IdentityCredentialDisconnectOptions : IdentityProviderConfig {
+  required USVString accountHint;
+};
+
 [Exposed=Window, SecureContext]
 interface IdentityCredential : Credential {
+  static Promise<undefined> disconnect(optional IdentityCredentialDisconnectOptions options = {});
   readonly attribute USVString? token;
 };
 
+dictionary DisconnectedAccount {
+  required USVString account_id;
+};
+
 partial dictionary CredentialRequestOptions {
   IdentityCredentialRequestOptions identity;
 };
@@ -35,13 +44,16 @@ enum IdentityCredentialRequestOptionsContext {
 };
 
 dictionary IdentityCredentialRequestOptions {
-  required sequence<IdentityProviderConfig> providers;
+  required sequence<IdentityProviderRequestOptions> providers;
   IdentityCredentialRequestOptionsContext context = "signin";
 };
 
 dictionary IdentityProviderConfig {
   required USVString configURL;
   required USVString clientId;
+};
+
+dictionary IdentityProviderRequestOptions : IdentityProviderConfig {
   USVString nonce;
   DOMString loginHint;
 };
@@ -67,6 +79,7 @@ dictionary IdentityProviderAPIConfig {
   required USVString client_metadata_endpoint;
   required USVString id_assertion_endpoint;
   required USVString login_url;
+  USVString disconnect_endpoint;
   IdentityProviderBranding branding;
 };
 

package/anonymous-iframe.idl

@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Iframe credentialless (https://wicg.github.io/anonymous-iframe/)
+
+partial interface HTMLIFrameElement {
+  attribute boolean credentialless;
+};
+
+partial interface Window {
+  readonly attribute boolean credentialless;
+};

package/css-transitions.idl

@@ -1,7 +1,7 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into webref
 // (https://github.com/w3c/webref)
-// Source: CSS Transitions (https://drafts.csswg.org/css-transitions-1/)
+// Source: CSS Transitions Level 1 (https://drafts.csswg.org/css-transitions-1/)
 
 [Exposed=Window]
 interface TransitionEvent : Event {

package/html.idl

@@ -1872,6 +1872,7 @@ interface Navigation : EventTarget {
   readonly attribute NavigationHistoryEntry? currentEntry;
   undefined updateCurrentEntry(NavigationUpdateCurrentEntryOptions options);
   readonly attribute NavigationTransition? transition;
+  readonly attribute NavigationActivation? activation;
 
   readonly attribute boolean canGoBack;
   readonly attribute boolean canGoForward;
@@ -1944,6 +1945,13 @@ interface NavigationTransition {
   readonly attribute Promise<undefined> finished;
 };
 
+[Exposed=Window]
+interface NavigationActivation {
+  readonly attribute NavigationHistoryEntry? from;
+  readonly attribute NavigationHistoryEntry entry;
+  readonly attribute NavigationType navigationType;
+};
+
 [Exposed=Window]
 interface NavigateEvent : Event {
   constructor(DOMString type, NavigateEventInit eventInitDict);
@@ -2083,12 +2091,12 @@ dictionary ErrorEventInit : EventInit {
 interface PromiseRejectionEvent : Event {
   constructor(DOMString type, PromiseRejectionEventInit eventInitDict);
 
-  readonly attribute Promise<any> promise;
+  readonly attribute object promise;
   readonly attribute any reason;
 };
 
 dictionary PromiseRejectionEventInit : EventInit {
-  required Promise<any> promise;
+  required object promise;
   any reason;
 };
 

package/orientation-event.idl

@@ -15,7 +15,7 @@ interface DeviceOrientationEvent : Event {
     readonly attribute double? gamma;
     readonly attribute boolean absolute;
 
-    static Promise<PermissionState> requestPermission();
+    static Promise<PermissionState> requestPermission(optional boolean absolute = false);
 };
 
 dictionary DeviceOrientationEventInit : EventInit {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webref/idl",
   "description": "Web IDL definitions of the web platform",
-  "version": "3.41.3",
+  "version": "3.42.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/w3c/webref.git"

package/uievents.idl

@@ -101,7 +101,7 @@ dictionary WheelEventInit : MouseEventInit {
 [Exposed=Window]
 interface InputEvent : UIEvent {
   constructor(DOMString type, optional InputEventInit eventInitDict = {});
-  readonly attribute DOMString? data;
+  readonly attribute USVString? data;
   readonly attribute boolean isComposing;
   readonly attribute DOMString inputType;
 };
@@ -147,7 +147,7 @@ dictionary KeyboardEventInit : EventModifierInit {
 [Exposed=Window]
 interface CompositionEvent : UIEvent {
   constructor(DOMString type, optional CompositionEventInit eventInitDict = {});
-  readonly attribute DOMString data;
+  readonly attribute USVString data;
 };
 
 dictionary CompositionEventInit : UIEventInit {

package/webnn.idl

@@ -37,35 +37,26 @@ interface ML {
 };
 
 [SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLGraph {};
-
-enum MLInputOperandLayout {
-  "nchw",
-  "nhwc"
+interface MLActivation {
 };
 
-enum MLOperandDataType {
-  "float32",
-  "float16",
-  "int32",
-  "uint32",
-  "int8",
-  "uint8"
-};
+typedef (GPUBuffer or GPUTexture) MLGPUResource;
 
-dictionary MLOperandDescriptor {
-  // The operand data type.
-  required MLOperandDataType dataType;
+typedef record<DOMString, MLGPUResource> MLNamedGPUResources;
 
-  // The dimensions field is only required for tensor operands.
-  sequence<unsigned long> dimensions;
+[SecureContext, Exposed=(Window, DedicatedWorker)]
+interface MLCommandEncoder {};
+
+partial interface MLCommandEncoder {
+  undefined initializeGraph(MLGraph graph);
 };
 
-[SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLOperand {};
+partial interface MLCommandEncoder {
+  undefined dispatch(MLGraph graph, MLNamedGPUResources inputs, MLNamedGPUResources outputs);
+};
 
-[SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLActivation {
+partial interface MLCommandEncoder {
+  GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
 };
 
 typedef record<DOMString, ArrayBufferView> MLNamedArrayBufferViews;
@@ -93,24 +84,8 @@ partial interface MLContext {
   MLCommandEncoder createCommandEncoder();
 };
 
-typedef (GPUBuffer or GPUTexture) MLGPUResource;
-
-typedef record<DOMString, MLGPUResource> MLNamedGPUResources;
-
 [SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLCommandEncoder {};
-
-partial interface MLCommandEncoder {
-  undefined initializeGraph(MLGraph graph);
-};
-
-partial interface MLCommandEncoder {
-  undefined dispatch(MLGraph graph, MLNamedGPUResources inputs, MLNamedGPUResources outputs);
-};
-
-partial interface MLCommandEncoder {
-  GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
-};
+interface MLGraph {};
 
 typedef record<DOMString, MLOperand> MLNamedOperands;
 
@@ -134,7 +109,7 @@ interface MLGraphBuilder {
   MLOperand constant(MLOperandDescriptor descriptor, MLBufferView bufferView);
 
   // Create a single-value operand from the specified number of the specified type.
-  MLOperand constant(double value, optional MLOperandDataType dataType = "float32");
+  MLOperand constant(double value, optional MLOperandDataType type = "float32");
 
   // Compile the graph up to the specified output operands asynchronously.
   Promise<MLGraph> build(MLNamedOperands outputs);
@@ -144,6 +119,17 @@ interface MLGraphBuilder {
   MLGraph buildSync(MLNamedOperands outputs);
 };
 
+dictionary MLArgMinMaxOptions {
+  sequence<unsigned long> axes = null;
+  boolean keepDimensions = false;
+  boolean selectLastIndex = false;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand argMin(MLOperand input, optional MLArgMinMaxOptions options = {});
+  MLOperand argMax(MLOperand input, optional MLArgMinMaxOptions options = {});
+};
+
 dictionary MLBatchNormalizationOptions {
   MLOperand scale;
   MLOperand bias;
@@ -157,13 +143,17 @@ partial interface MLGraphBuilder {
                              optional MLBatchNormalizationOptions options = {});
 };
 
+partial interface MLGraphBuilder {
+  MLOperand cast(MLOperand input, MLOperandDataType type);
+};
+
 dictionary MLClampOptions {
   float minValue;
   float maxValue;
 };
 
 partial interface MLGraphBuilder {
-  MLOperand clamp(MLOperand operand, optional MLClampOptions options = {});
+  MLOperand clamp(MLOperand input, optional MLClampOptions options = {});
   MLActivation clamp(optional MLClampOptions options = {});
 };
 
@@ -235,15 +225,28 @@ partial interface MLGraphBuilder {
   MLOperand pow(MLOperand a, MLOperand b);
 };
 
+partial interface MLGraphBuilder {
+  MLOperand equal(MLOperand a, MLOperand b);
+  MLOperand greater(MLOperand a, MLOperand b);
+  MLOperand greaterOrEqual(MLOperand a, MLOperand b);
+  MLOperand lesser(MLOperand a, MLOperand b);
+  MLOperand lesserOrEqual(MLOperand a, MLOperand b);
+  MLOperand not(MLOperand a);
+};
+
 partial interface MLGraphBuilder {
   MLOperand abs(MLOperand input);
   MLOperand ceil(MLOperand input);
   MLOperand cos(MLOperand input);
+  MLOperand erf(MLOperand input);
   MLOperand exp(MLOperand input);
   MLOperand floor(MLOperand input);
+  MLOperand identity(MLOperand input);
   MLOperand log(MLOperand input);
   MLOperand neg(MLOperand input);
+  MLOperand reciprocal(MLOperand input);
   MLOperand sin(MLOperand input);
+  MLOperand sqrt(MLOperand input);
   MLOperand tan(MLOperand input);
 };
 
@@ -256,6 +259,18 @@ partial interface MLGraphBuilder {
   MLActivation elu(optional MLEluOptions options = {});
 };
 
+partial interface MLGraphBuilder {
+  MLOperand expand(MLOperand input, sequence<unsigned long> newShape);
+};
+
+dictionary MLGatherOptions {
+  unsigned long axis = 0;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand gather(MLOperand input, MLOperand indices, optional MLGatherOptions options = {});
+};
+
 dictionary MLGemmOptions {
   MLOperand c;
   float alpha = 1.0;
@@ -337,6 +352,17 @@ partial interface MLGraphBuilder {
                                 optional MLInstanceNormalizationOptions options = {});
 };
 
+dictionary MLLayerNormalizationOptions {
+  MLOperand scale;
+  MLOperand bias;
+  sequence<unsigned long> axes;
+  float epsilon = 1e-5;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand layerNormalization(MLOperand input, optional MLLayerNormalizationOptions options = {});
+};
+
 dictionary MLLeakyReluOptions {
   float alpha = 0.01;
 };
@@ -523,14 +549,6 @@ partial interface MLGraphBuilder {
                           optional MLSplitOptions options = {});
 };
 
-dictionary MLSqueezeOptions {
-  sequence<unsigned long> axes;
-};
-
-partial interface MLGraphBuilder {
-  MLOperand squeeze(MLOperand input, optional MLSqueezeOptions options = {});
-};
-
 partial interface MLGraphBuilder {
   MLOperand tanh(MLOperand input);
   MLActivation tanh();
@@ -543,3 +561,51 @@ dictionary MLTransposeOptions {
 partial interface MLGraphBuilder {
   MLOperand transpose(MLOperand input, optional MLTransposeOptions options = {});
 };
+
+dictionary MLTriangularOptions {
+  boolean upper = true;
+  long diagonal = 0;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand triangular(MLOperand input, optional MLTriangularOptions options = {});
+};
+
+partial interface MLGraphBuilder {
+  MLOperand where(MLOperand condition, MLOperand input, MLOperand other);
+};
+
+[SecureContext, Exposed=(Window, DedicatedWorker)]
+interface MLOperand {};
+
+partial interface MLOperand {
+  MLOperandDataType dataType();
+};
+
+partial interface MLOperand {
+  sequence<unsigned long> shape();
+};
+
+enum MLInputOperandLayout {
+  "nchw",
+  "nhwc"
+};
+
+enum MLOperandDataType {
+  "float32",
+  "float16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "int8",
+  "uint8"
+};
+
+dictionary MLOperandDescriptor {
+  // The operand type.
+  required MLOperandDataType dataType;
+
+  // The dimensions field is only required for tensor operands.
+  sequence<unsigned long> dimensions;
+};

package/webrtc-encoded-transform.idl

@@ -112,12 +112,16 @@ partial interface DedicatedWorkerGlobalScope {
 };
 
 [Exposed=DedicatedWorker]
-interface RTCRtpScriptTransformer {
+interface RTCRtpScriptTransformer : EventTarget {
+    // Attributes and methods related to the transformer source
     readonly attribute ReadableStream readable;
-    readonly attribute WritableStream writable;
-    readonly attribute any options;
     Promise<unsigned long long> generateKeyFrame(optional DOMString rid);
     Promise<undefined> sendKeyFrameRequest();
+    // Attributes and methods related to the transformer sink
+    readonly attribute WritableStream writable;
+    attribute EventHandler onkeyframerequest;
+    // Attributes for configuring the Javascript code
+    readonly attribute any options;
 };
 
 [Exposed=Window]
@@ -125,6 +129,12 @@ interface RTCRtpScriptTransform {
     constructor(Worker worker, optional any options, optional sequence<object> transfer);
 };
 
+[Exposed=DedicatedWorker]
+interface KeyFrameRequestEvent : Event {
+  constructor(DOMString type, optional DOMString rid);
+  readonly attribute DOMString? rid;
+};
+
 partial interface RTCRtpSender {
     Promise<undefined> generateKeyFrame(optional sequence <DOMString> rids);
 };

package/webtransport.idl

@@ -39,6 +39,8 @@ interface WebTransport {
   /* a ReadableStream of WebTransportReceiveStream objects */
   readonly attribute ReadableStream incomingUnidirectionalStreams;
   WebTransportSendGroup createSendGroup();
+
+  static readonly attribute boolean supportsReliableOnly;
 };
 
 enum WebTransportReliabilityMode {