API documentation  2.0rc1
clientlib.h
1 /****************************************************************
2  *
3  * Copyright (C) 2013-2016 Alessandro Pignotti <alessandro@leaningtech.com>
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  ***************************************************************/
20 
21 #ifndef _CHEERP_CLIENTLIB_acc90e6e
22 #define _CHEERP_CLIENTLIB_acc90e6e
23 #include "types.h"
24 
25 #include <utility>
26 
27 namespace [[cheerp::genericjs]] client
28 {
29  class PropertyDescriptor;
31  class IArguments;
32  template<class T>
35  class ImportMeta;
36  class Math;
37  class Date;
38  class RegExpMatchArray;
39  class RegExpExecArray;
40  class RegExp;
41  class Error;
42  class EvalError;
43  class RangeError;
44  class ReferenceError;
45  class SyntaxError;
46  class TypeError;
47  class URIError;
48  class JSON;
49  template<class T>
50  class ConcatArray;
51  template<class T>
53  class Promise;
54  template<class T>
55  class ThisType;
56  class ArrayBuffer;
57  class ArrayBufferTypes;
58  class ArrayBufferView;
59  class DataView;
60  class Int8Array;
61  class Uint8Array;
62  class Uint8ClampedArray;
63  class Int16Array;
64  class Uint16Array;
65  class Int32Array;
66  class Uint32Array;
67  class Float32Array;
68  class Float64Array;
69  class Account;
72  class Algorithm;
73  class AesCbcParams;
74  class AesCtrParams;
75  class AesDerivedKeyParams;
76  class AesGcmParams;
77  class KeyAlgorithm;
78  class AesKeyAlgorithm;
79  class AesKeyGenParams;
80  class AudioNodeOptions;
81  class AnalyserOptions;
82  class EventInit;
83  class AnimationEventInit;
84  class AssertionOptions;
85  class AudioBufferOptions;
87  class AudioContextInfo;
88  class AudioContextOptions;
91  class AudioTimestamp;
92  class BiquadFilterOptions;
93  class ByteLengthChunk;
94  class CacheQueryOptions;
97  class ClientData;
98  class ClientQueryOptions;
99  class CloseEventInit;
100  class UIEventInit;
101  class CompositionEventInit;
102  class ExceptionInformation;
104  class ConstantSourceOptions;
107  class DoubleRange;
108  class ConstrainDoubleRange;
109  class LongRange;
110  class ConstrainLongRange;
112  class ConvolverOptions;
113  template<class T>
115  class DOMRectInit;
116  class DelayOptions;
118  class DeviceLightEventInit;
119  class DeviceMotionEventInit;
123  class EcKeyAlgorithm;
124  class EcKeyGenParams;
125  class EcKeyImportParams;
126  class EcdhKeyDeriveParams;
127  class EcdsaParams;
128  class ErrorEventInit;
129  class EventModifierInit;
130  class ExtendableEventInit;
132  class FetchEventInit;
133  class FocusEventInit;
135  class FocusNavigationOrigin;
136  class GainOptions;
137  class GamepadEventInit;
139  class HashChangeEventInit;
140  class HkdfParams;
141  class HmacImportParams;
142  class HmacKeyAlgorithm;
143  class HmacKeyGenParams;
144  class IDBIndexParameters;
146  class IIRFilterOptions;
149  class JsonWebKey;
150  class KeyboardEventInit;
151  class MSAccountInfo;
152  class RTCStats;
155  class MSPayloadBase;
156  class MSAudioRecvPayload;
157  class MSAudioRecvSignal;
158  class MSAudioSendPayload;
159  class MSAudioSendSignal;
160  class MSConnectivity;
161  class MSCredentialFilter;
163  class MSCredentialSpec;
164  class MSDCCEventInit;
165  class MSDSHEventInit;
166  class MSDelay;
167  class MSDescription;
169  class MSIPAddressInfo;
170  class MSIceWarningFlags;
171  class MSJitter;
172  class MSNetwork;
175  class MSOutboundNetwork;
176  class MSPacketLoss;
177  class MSPortRange;
178  class MSRelayAddress;
179  class MSSignatureParameters;
181  class MSUtilization;
182  class MSVideoPayload;
183  class MSVideoRecvPayload;
185  class MSVideoSendPayload;
193  class MediaStreamEventInit;
197  class MediaTrackConstraints;
198  class MediaTrackSettings;
200  class MessageEventInit;
201  class MouseEventInit;
202  class MsZoomToOptions;
203  class MutationObserverInit;
204  class NotificationEventInit;
205  class NotificationOptions;
206  class ObjectURLOptions;
208  class OscillatorOptions;
209  class PannerOptions;
210  class PaymentCurrencyAmount;
211  class PaymentDetailsBase;
212  class PaymentDetailsInit;
214  class PaymentDetailsUpdate;
215  class PaymentItem;
216  class PaymentMethodData;
217  class PaymentOptions;
219  class PaymentShippingOption;
220  class Pbkdf2Params;
222  class PeriodicWaveOptions;
223  class PointerEventInit;
224  class PopStateEventInit;
225  class PositionOptions;
226  class ProgressEventInit;
227  class PushEventInit;
230  class QueuingStrategy;
231  class RTCConfiguration;
233  class RTCDtlsFingerprint;
234  class RTCDtlsParameters;
238  class RTCIceCandidateInit;
239  class RTCIceCandidatePair;
241  class RTCIceGatherOptions;
242  class RTCIceParameters;
243  class RTCIceServer;
244  class RTCRTPStreamStats;
247  class RTCOfferOptions;
250  class RTCRtcpFeedback;
251  class RTCRtcpParameters;
252  class RTCRtpCapabilities;
253  class RTCRtpCodecCapability;
254  class RTCRtpCodecParameters;
257  class RTCRtpFecParameters;
258  class RTCRtpHeaderExtension;
260  class RTCRtpParameters;
261  class RTCRtpRtxParameters;
262  class RTCRtpUnhandled;
264  class RTCSrtpKeyParam;
265  class RTCSrtpSdesParameters;
266  class RTCSsrcRange;
267  class RTCStatsReport;
268  class RTCTransportStats;
269  class RegistrationOptions;
270  class RequestInit;
271  class ResponseInit;
272  class RsaHashedImportParams;
273  class RsaKeyAlgorithm;
274  class RsaHashedKeyAlgorithm;
275  class RsaKeyGenParams;
276  class RsaHashedKeyGenParams;
277  class RsaOaepParams;
278  class RsaOtherPrimesInfo;
279  class RsaPssParams;
286  class StereoPannerOptions;
289  class SyncEventInit;
290  class TextDecodeOptions;
291  class TextDecoderOptions;
292  class TrackEventInit;
293  class TransitionEventInit;
294  class UnderlyingSink;
295  class VRDisplayEventInit;
296  class VRLayer;
297  class VRStageParameters;
298  class WaveShaperOptions;
299  class WebAuthnExtensions;
300  class WheelEventInit;
301  class EventListener;
303  class AbortController;
304  class AbortSignalEventMap;
305  class EventTarget;
306  class AbortSignal;
308  class AbstractWorker;
309  class AesCfbParams;
310  class AesCmacParams;
311  class AudioNode;
312  class AnalyserNode;
313  class Animation;
315  class Event;
316  class AnimationEvent;
317  class AnimationKeyFrame;
318  class AnimationOptions;
321  class AnimationTimeline;
323  class ApplicationCache;
324  class AssignedNodesOptions;
325  class Node;
326  class Attr;
327  class AudioBuffer;
329  class AudioBufferSourceNode;
330  class AudioContextEventMap;
331  class AudioContextBase;
332  class AudioContext;
333  class AudioDestinationNode;
334  class AudioListener;
335  class AudioParam;
336  class AudioProcessingEvent;
337  class AudioTrack;
339  class AudioTrackList;
340  class BarProp;
341  class BeforeUnloadEvent;
342  class BhxBrowser;
343  class BiquadFilterNode;
344  class Blob;
345  class BlobPropertyBag;
346  class Body;
347  class BroadcastChannel;
350  class ChildNode;
351  class CharacterData;
352  class Text;
353  class CDATASection;
354  class CSS;
355  class CSSRule;
356  class CSSGroupingRule;
357  class CSSConditionRule;
358  class CSSFontFaceRule;
359  class CSSImportRule;
360  class CSSKeyframeRule;
361  class CSSKeyframesRule;
362  class CSSMediaRule;
363  class CSSNamespaceRule;
364  class CSSPageRule;
365  class CSSRuleList;
366  class CSSStyleDeclaration;
367  class CSSStyleRule;
368  class StyleSheet;
369  class CSSStyleSheet;
370  class CSSSupportsRule;
371  class Cache;
372  class CacheStorage;
374  class CanvasGradient;
375  class CanvasPathMethods;
376  class CanvasPattern;
378  class ChannelMergerNode;
379  class ChannelSplitterNode;
380  class ClientRect;
381  class ClientRectList;
382  class ClipboardEvent;
383  class ClipboardEventInit;
384  class CloseEvent;
385  class Comment;
386  class UIEvent;
387  class CompositionEvent;
389  class ConcatParams;
390  class Console;
392  class ConvolverNode;
393  class Coordinates;
394  class CountQueuingStrategy;
395  class Crypto;
396  class CryptoKey;
397  class CryptoKeyPair;
398  class CustomElementRegistry;
399  template<class T>
400  class CustomEvent;
401  class DOMError;
402  class DOMException;
403  class DOMImplementation;
406  class DOMParser;
407  class DOMRectReadOnly;
408  class DOMRect;
409  class DOMRectList;
410  class DOMTokenList;
411  class DOMSettableTokenList;
412  class DOMStringList;
413  class DOMStringMap;
414  class TextTrackCue;
415  class DataCue;
416  class DataTransfer;
417  class DataTransferItem;
418  class DataTransferItemList;
420  class DelayNode;
421  class DeviceAcceleration;
422  class DeviceLightEvent;
423  class DeviceMotionEvent;
425  class DeviceRotationRate;
426  class DhImportKeyParams;
427  class DhKeyAlgorithm;
428  class DhKeyDeriveParams;
429  class DhKeyGenParams;
431  class DocumentEventMap;
432  class GlobalEventHandlers;
433  class ParentNode;
434  class DocumentEvent;
435  class Document;
436  class DocumentFragment;
437  class DocumentOrShadowRoot;
438  class DocumentType;
439  class MouseEvent;
440  class DragEvent;
442  class EXT_blend_minmax;
443  class EXT_frag_depth;
444  class EXT_sRGB;
447  class ElementEventMap;
448  class ElementTraversal;
449  class Element;
450  class ElementCSSInlineStyle;
453  class ErrorEvent;
454  class EventListenerObject;
455  class EventSource;
456  class EventSourceInit;
457  class ExtensionScriptApis;
458  class External;
459  class File;
460  class FileList;
461  class FilePropertyBag;
462  class FileReaderEventMap;
463  class FileReader;
464  class ProgressEvent;
466  class FocusEvent;
467  class FocusNavigationEvent;
468  class FormData;
469  class GainNode;
470  class Gamepad;
471  class GamepadButton;
472  class GamepadEvent;
473  class GamepadHapticActuator;
474  class GamepadPose;
475  class Geolocation;
476  class GetSVGDocument;
477  class GlobalFetch;
478  class HTMLAllCollection;
479  class HTMLElement;
481  class HTMLAnchorElement;
482  class HTMLAppletElement;
483  class HTMLAreaElement;
484  class HTMLCollectionBase;
485  class HTMLAreasCollection;
486  class HTMLMediaElement;
487  class HTMLAudioElement;
488  class HTMLBRElement;
489  class HTMLBaseElement;
490  class HTMLBaseFontElement;
491  class HTMLElementEventMap;
494  class WindowEventHandlers;
495  class HTMLBodyElement;
496  class HTMLButtonElement;
497  class HTMLCanvasElement;
498  class HTMLCollection;
499  template<class T>
501  class HTMLDListElement;
502  class HTMLDataElement;
503  class HTMLDataListElement;
504  class HTMLDetailsElement;
505  class HTMLDialogElement;
506  class HTMLDirectoryElement;
507  class HTMLDivElement;
508  class HTMLDocument;
509  class HTMLEmbedElement;
510  class HTMLFieldSetElement;
511  class HTMLFontElement;
513  class HTMLFormElement;
515  class HTMLFrameElement;
517  class HTMLFrameSetElement;
518  class HTMLHRElement;
519  class HTMLHeadElement;
520  class HTMLHeadingElement;
521  class HTMLHtmlElement;
523  class HTMLIFrameElement;
524  class HTMLImageElement;
525  class HTMLInputElement;
526  class HTMLLIElement;
527  class HTMLLabelElement;
528  class HTMLLegendElement;
529  class LinkStyle;
530  class HTMLLinkElement;
531  class HTMLMainElement;
532  class HTMLMapElement;
534  class HTMLMarqueeElement;
536  class HTMLMenuElement;
537  class HTMLMetaElement;
538  class HTMLMeterElement;
539  class HTMLModElement;
540  class HTMLOListElement;
541  class HTMLObjectElement;
542  class HTMLOptGroupElement;
543  class HTMLOptionElement;
544  class HTMLOptionsCollection;
545  class HTMLOutputElement;
546  class HTMLParagraphElement;
547  class HTMLParamElement;
548  class HTMLPictureElement;
549  class HTMLPreElement;
550  class HTMLProgressElement;
551  class HTMLQuoteElement;
552  class HTMLScriptElement;
553  class HTMLSelectElement;
554  class HTMLSlotElement;
555  class HTMLSourceElement;
556  class HTMLSpanElement;
557  class HTMLStyleElement;
558  class HTMLSummaryElement;
560  class HTMLTableCellElement;
561  class HTMLTableColElement;
563  class HTMLTableElement;
565  class HTMLTableRowElement;
567  class HTMLTemplateElement;
568  class HTMLTextAreaElement;
569  class HTMLTimeElement;
570  class HTMLTitleElement;
571  class HTMLTrackElement;
572  class HTMLUListElement;
573  class HTMLUnknownElement;
575  class HTMLVideoElement;
576  class HTMLegendElement;
577  class HashChangeEvent;
578  class Headers;
579  class History;
580  class HkdfCtrParams;
581  class IDBArrayKey;
582  class IDBCursor;
583  class IDBCursorWithValue;
584  class IDBDatabaseEventMap;
585  class IDBDatabase;
586  class IDBEnvironment;
587  class IDBFactory;
588  class IDBIndex;
589  class IDBKeyRange;
590  class IDBObjectStore;
591  class IDBRequestEventMap;
593  class IDBRequest;
594  class IDBOpenDBRequest;
596  class IDBTransaction;
597  class IDBVersionChangeEvent;
598  class IIRFilterNode;
599  class ImageBitmap;
600  class ImageBitmapOptions;
601  class ImageData;
602  class IntersectionObserver;
604  class KeyboardEvent;
606  class Location;
607  class MSAssertion;
608  class MSBlobBuilder;
609  class MSCredentials;
610  class MSDCCEvent;
611  class MSDSHEvent;
613  class MSFIDOSignature;
615  class MSFileSaver;
616  class MSGesture;
617  class MSGestureEvent;
618  class MSGraphicsTrust;
620  class MSInputMethodContext;
621  class MSMediaKeyError;
623  class MSMediaKeyNeededEvent;
624  class MSMediaKeySession;
625  class MSMediaKeys;
626  class MSNavigatorDoNotTrack;
627  class MSPointerEvent;
628  class MSStream;
630  class MSStreamReader;
631  class MediaDeviceInfo;
632  class MediaDevicesEventMap;
633  class MediaDevices;
635  class MediaEncryptedEvent;
636  class MediaError;
637  class MediaKeyMessageEvent;
638  class MediaKeySession;
639  class MediaKeyStatusMap;
640  class MediaKeySystemAccess;
641  class MediaKeys;
642  class MediaList;
643  class MediaQueryList;
644  class MediaSource;
645  class MediaStreamEventMap;
646  class MediaStream;
648  class MediaStreamError;
649  class MediaStreamErrorEvent;
650  class MediaStreamEvent;
652  class MediaStreamTrack;
653  class MediaStreamTrackEvent;
654  class MessageChannel;
655  class MessageEvent;
656  class MessagePortEventMap;
657  class MessagePort;
658  class MimeType;
659  class MimeTypeArray;
660  class MutationEvent;
661  class MutationObserver;
662  class MutationRecord;
663  class NamedNodeMap;
664  class NavigatorID;
665  class NavigatorOnLine;
666  class NavigatorContentUtils;
667  class NavigatorStorageUtils;
668  class NavigatorBeacon;
670  class NavigatorUserMedia;
671  class NavigatorLanguage;
672  class Navigator;
673  class NodeFilter;
674  class NodeIterator;
675  class NodeList;
676  template<class TNode>
677  class NodeListOf;
678  class NodeSelector;
679  class NotificationEventMap;
680  class Notification;
683  class OfflineAudioContext;
685  class OscillatorNode;
686  class OverflowEvent;
687  class PageTransitionEvent;
688  class PannerNode;
689  class Path2D;
690  class PaymentAddress;
692  class PaymentRequest;
694  class PaymentResponse;
695  class PerfWidgetExternal;
696  class Performance;
697  class PerformanceEntry;
698  class PerformanceMark;
699  class PerformanceMeasure;
700  class PerformanceNavigation;
703  class PerformanceTiming;
704  class PeriodicWave;
705  class PermissionRequest;
707  class Plugin;
708  class PluginArray;
709  class PointerEvent;
710  class PopStateEvent;
711  class Position;
712  class PositionError;
713  class ProcessingInstruction;
714  class PromiseRejectionEvent;
716  class PushManager;
717  class PushSubscription;
721  class RTCStatsProvider;
722  class RTCDtlsTransport;
724  class RTCDtmfSenderEventMap;
725  class RTCDtmfSender;
726  class RTCIceCandidate;
729  class RTCIceGatherer;
730  class RTCIceGathererEvent;
732  class RTCIceTransport;
735  class RTCPeerConnection;
738  class RTCRtpReceiver;
739  class RTCRtpSenderEventMap;
740  class RTCRtpSender;
741  class RTCSessionDescription;
743  class RTCSrtpSdesTransport;
744  class RTCSsrcConflictEvent;
745  class RandomSource;
746  class Range;
747  class ReadableStream;
748  class ReadableStreamReader;
749  class Request;
750  class Response;
751  class SVGElement;
752  class SVGTests;
753  class SVGGraphicsElement;
754  class SVGURIReference;
755  class SVGAElement;
756  class SVGAngle;
757  class SVGAnimatedAngle;
758  class SVGAnimatedBoolean;
760  class SVGAnimatedInteger;
761  class SVGAnimatedLength;
762  class SVGAnimatedLengthList;
763  class SVGAnimatedNumber;
764  class SVGAnimatedNumberList;
765  class SVGAnimatedPoints;
767  class SVGAnimatedRect;
768  class SVGAnimatedString;
770  class SVGCircleElement;
771  class SVGUnitTypes;
772  class SVGClipPathElement;
774  class SVGDefsElement;
775  class SVGDescElement;
776  class SVGElementEventMap;
777  class SVGElementInstance;
779  class SVGEllipseElement;
781  class SVGFEBlendElement;
784  class SVGFECompositeElement;
789  class SVGFEFloodElement;
790  class SVGFEFuncAElement;
791  class SVGFEFuncBElement;
792  class SVGFEFuncGElement;
793  class SVGFEFuncRElement;
795  class SVGFEImageElement;
796  class SVGFEMergeElement;
797  class SVGFEMergeNodeElement;
799  class SVGFEOffsetElement;
802  class SVGFESpotLightElement;
803  class SVGFETileElement;
805  class SVGFilterElement;
806  class SVGFitToViewBox;
808  class SVGGElement;
809  class SVGGradientElement;
810  class SVGImageElement;
811  class SVGLength;
812  class SVGLengthList;
813  class SVGLineElement;
815  class SVGMarkerElement;
816  class SVGMaskElement;
817  class SVGMatrix;
818  class SVGMetadataElement;
819  class SVGNumber;
820  class SVGNumberList;
821  class SVGPathElement;
822  class SVGPathSeg;
823  class SVGPathSegArcAbs;
824  class SVGPathSegArcRel;
825  class SVGPathSegClosePath;
834  class SVGPathSegLinetoAbs;
837  class SVGPathSegLinetoRel;
840  class SVGPathSegList;
841  class SVGPathSegMovetoAbs;
842  class SVGPathSegMovetoRel;
843  class SVGPatternElement;
844  class SVGPoint;
845  class SVGPointList;
846  class SVGPolygonElement;
847  class SVGPolylineElement;
850  class SVGRect;
851  class SVGRectElement;
852  class SVGSVGElementEventMap;
853  class SVGZoomAndPan;
854  class SVGSVGElement;
855  class SVGScriptElement;
856  class SVGStopElement;
857  class SVGStringList;
858  class SVGStylable;
859  class SVGStyleElement;
860  class SVGSwitchElement;
861  class SVGSymbolElement;
862  class SVGTextContentElement;
864  class SVGTSpanElement;
865  class SVGTextElement;
866  class SVGTextPathElement;
867  class SVGTitleElement;
868  class SVGTransform;
869  class SVGTransformList;
870  class SVGUseElement;
871  class SVGViewElement;
872  class SVGZoomEvent;
873  class ScopedCredential;
874  class ScopedCredentialInfo;
875  class ScreenEventMap;
876  class Screen;
878  class ScriptProcessorNode;
879  class ScrollOptions;
880  class ScrollIntoViewOptions;
881  class ScrollToOptions;
883  class Selection;
884  class ServiceUIFrameContext;
885  class ServiceWorkerEventMap;
886  class ServiceWorker;
892  class ShadowRoot;
893  class ShadowRootInit;
894  class SourceBuffer;
895  class SourceBufferList;
897  class SpeechSynthesis;
898  class SpeechSynthesisEvent;
901  class SpeechSynthesisVoice;
902  class StereoPannerNode;
903  class Storage;
904  class StorageEvent;
905  class StorageEventInit;
906  class StyleMedia;
907  class StyleSheetList;
908  class SubtleCrypto;
909  class SyncManager;
910  class TextDecoder;
911  class TextEncoder;
912  class TextEvent;
913  class TextMetrics;
914  class TextTrackEventMap;
915  class TextTrack;
916  class TextTrackCueEventMap;
917  class TextTrackCueList;
918  class TextTrackListEventMap;
919  class TextTrackList;
920  class TimeRanges;
921  class Touch;
922  class TouchEvent;
923  class TouchEventInit;
924  class TouchList;
925  class TrackEvent;
926  class TransitionEvent;
927  class TreeWalker;
928  class URL;
929  class URLSearchParams;
930  class VRDisplay;
931  class VRDisplayCapabilities;
932  class VRDisplayEvent;
933  class VREyeParameters;
934  class VRFieldOfView;
935  class VRFrameData;
936  class VRPose;
937  class ValidityState;
938  class VideoPlaybackQuality;
939  class VideoTrack;
941  class VideoTrackList;
942  class WaveShaperNode;
943  class WebAuthentication;
944  class WebAuthnAssertion;
945  class WebKitCSSMatrix;
946  class WebKitEntry;
947  class WebKitDirectoryEntry;
948  class WebKitDirectoryReader;
949  class WebKitFileEntry;
950  class WebKitFileSystem;
951  class WebKitPoint;
952  class WebSocketEventMap;
953  class WebSocket;
954  class WheelEvent;
955  class WindowEventMap;
956  class WindowTimersExtension;
957  class WindowTimers;
958  class WindowSessionStorage;
959  class WindowLocalStorage;
960  class WindowConsole;
961  class WindowBase64;
962  class Window;
963  class WorkerEventMap;
964  class Worker;
965  class WritableStream;
968  class XMLDocument;
972  class XMLHttpRequest;
973  class XMLHttpRequestUpload;
974  class XMLSerializer;
975  class XPathEvaluator;
976  class XPathExpression;
977  class XPathNSResolver;
978  class XPathResult;
979  class XSLTProcessor;
981  class DecodeErrorCallback;
982  class DecodeSuccessCallback;
983  class ErrorEventHandler;
984  class EventHandlerNonNull;
985  class ForEachCallback;
986  class FrameRequestCallback;
989  class MSLaunchUriCallback;
991  class MutationCallback;
995  class PositionCallback;
996  class PositionErrorCallback;
999  class RTCStatsCallback;
1000  class VoidFunction;
1004  class HTMLElementTagNameMap;
1005  class SVGElementTagNameMap;
1006  class ElementTagNameMap;
1007  class ActiveXObject;
1008  class ITextWriter;
1009  class TextStreamBase;
1010  class TextStreamWriter;
1011  class TextStreamReader;
1013  public:
1014  bool get_configurable();
1015  void set_configurable(bool);
1016  bool get_enumerable();
1017  void set_enumerable(bool);
1018  Object* get_value();
1019  void set_value(Object*);
1020  bool get_writable();
1021  void set_writable(bool);
1022  Object* get();
1023  void set(Object* v);
1024  };
1025 
1027  public:
1029  {
1030  return __builtin_cheerp_make_regular<PropertyDescriptor*>(this, 0)[index];
1031  }
1032  PropertyDescriptor* operator[](int index) const
1033  {
1034  return __builtin_cheerp_make_regular<PropertyDescriptor*>(this, 0)[index];
1035  }
1036  };
1037 
1038  class IArguments: public Object{
1039  public:
1040  Object*& operator[](int index)
1041  {
1042  return __builtin_cheerp_make_regular<Object*>(this, 0)[index];
1043  }
1044  Object* operator[](int index) const
1045  {
1046  return __builtin_cheerp_make_regular<Object*>(this, 0)[index];
1047  }
1048  double get_length();
1049  void set_length(double);
1050  Function* get_callee();
1051  void set_callee(Function*);
1052  };
1053 
1054  template<class T>
1055  class ReadonlyArray: public Object{
1056  public:
1057  double get_length();
1058  String* toString();
1059  String* toLocaleString();
1060  template<typename... Args> Array* concat(Args&&... items) { return static_cast<const ReadonlyArray*>(this)->concat(static_cast<Object*>(static_cast<Args&&>(items))...); }
1061  Array* concat();
1062  String* join();
1063  String* join(const String& separator);
1064  Array* slice();
1065  Array* slice(double start);
1066  Array* slice(double start, double end);
1067  double indexOf(T* searchElement);
1068  double indexOf(T* searchElement, double fromIndex);
1069  double lastIndexOf(T* searchElement);
1070  double lastIndexOf(T* searchElement, double fromIndex);
1071  bool every(EventListener* callbackfn);
1072  bool every(EventListener* callbackfn, Object* thisArg);
1073  bool some(EventListener* callbackfn);
1074  bool some(EventListener* callbackfn, Object* thisArg);
1075  void forEach(EventListener* callbackfn);
1076  void forEach(EventListener* callbackfn, Object* thisArg);
1077  template<class U> Array* map(EventListener* callbackfn);
1078  template<class U> Array* map(EventListener* callbackfn, Object* thisArg);
1079  Array* filter(EventListener* callbackfn);
1080  Array* filter(EventListener* callbackfn, Object* thisArg);
1081  T* reduce(EventListener* callbackfn);
1082  T* reduce(EventListener* callbackfn, T* initialValue);
1083  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1084  T* reduceRight(EventListener* callbackfn);
1085  T* reduceRight(EventListener* callbackfn, T* initialValue);
1086  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1087  T*& operator[](int index)
1088  {
1089  return __builtin_cheerp_make_regular<T*>(this, 0)[index];
1090  }
1091  T* operator[](int index) const
1092  {
1093  return __builtin_cheerp_make_regular<T*>(this, 0)[index];
1094  }
1095  private:
1096  template<typename... Args> Array* concat(Args... items) const;
1097  };
1098 
1099  class TemplateStringsArray: public ReadonlyArray<String> {
1100  public:
1101  ReadonlyArray<String>* get_raw();
1102  };
1103 
1104  class ImportMeta: public Object{
1105  public:
1106  };
1107 
1108  class Math: public Object{
1109  public:
1110  double get_E();
1111  double get_LN10();
1112  double get_LN2();
1113  double get_LOG2E();
1114  double get_LOG10E();
1115  double get_PI();
1116  double get_SQRT1_2();
1117  double get_SQRT2();
1118  double abs(double x);
1119  double acos(double x);
1120  double asin(double x);
1121  double atan(double x);
1122  double atan2(double y, double x);
1123  double ceil(double x);
1124  double cos(double x);
1125  double exp(double x);
1126  double floor(double x);
1127  double log(double x);
1128  template<typename... Args> double max(Args&&... values) { return static_cast<const Math*>(this)->max(static_cast<double>(static_cast<Args&&>(values))...); }
1129  double max();
1130  template<typename... Args> double min(Args&&... values) { return static_cast<const Math*>(this)->min(static_cast<double>(static_cast<Args&&>(values))...); }
1131  double min();
1132  double pow(double x, double y);
1133  double random();
1134  double round(double x);
1135  double sin(double x);
1136  double sqrt(double x);
1137  double tan(double x);
1138  private:
1139  template<typename... Args> double max(Args... values) const;
1140  template<typename... Args> double min(Args... values) const;
1141  };
1142 
1143  class Date: public Object{
1144  public:
1145  String* toString();
1146  String* toDateString();
1147  String* toTimeString();
1148  String* toLocaleString();
1149  String* toLocaleDateString();
1150  String* toLocaleTimeString();
1151  double valueOf();
1152  double getTime();
1153  double getFullYear();
1154  double getUTCFullYear();
1155  double getMonth();
1156  double getUTCMonth();
1157  double getDate();
1158  double getUTCDate();
1159  double getDay();
1160  double getUTCDay();
1161  double getHours();
1162  double getUTCHours();
1163  double getMinutes();
1164  double getUTCMinutes();
1165  double getSeconds();
1166  double getUTCSeconds();
1167  double getMilliseconds();
1168  double getUTCMilliseconds();
1169  double getTimezoneOffset();
1170  double setTime(double time);
1171  double setMilliseconds(double ms);
1172  double setUTCMilliseconds(double ms);
1173  double setSeconds(double sec);
1174  double setSeconds(double sec, double ms);
1175  double setUTCSeconds(double sec);
1176  double setUTCSeconds(double sec, double ms);
1177  double setMinutes(double min);
1178  double setMinutes(double min, double sec);
1179  double setMinutes(double min, double sec, double ms);
1180  double setUTCMinutes(double min);
1181  double setUTCMinutes(double min, double sec);
1182  double setUTCMinutes(double min, double sec, double ms);
1183  double setHours(double hours);
1184  double setHours(double hours, double min);
1185  double setHours(double hours, double min, double sec);
1186  double setHours(double hours, double min, double sec, double ms);
1187  double setUTCHours(double hours);
1188  double setUTCHours(double hours, double min);
1189  double setUTCHours(double hours, double min, double sec);
1190  double setUTCHours(double hours, double min, double sec, double ms);
1191  double setDate(double date);
1192  double setUTCDate(double date);
1193  double setMonth(double month);
1194  double setMonth(double month, double date);
1195  double setUTCMonth(double month);
1196  double setUTCMonth(double month, double date);
1197  double setFullYear(double year);
1198  double setFullYear(double year, double month);
1199  double setFullYear(double year, double month, double date);
1200  double setUTCFullYear(double year);
1201  double setUTCFullYear(double year, double month);
1202  double setUTCFullYear(double year, double month, double date);
1203  String* toUTCString();
1204  String* toISOString();
1205  String* toJSON();
1206  String* toJSON(Object* key);
1207  EventListener* get_getVarDate();
1208  void set_getVarDate(EventListener*);
1209  Date();
1210  Date(double value);
1211  Date(const String& value);
1212  Date(double year, double month);
1213  Date(double year, double month, double date);
1214  Date(double year, double month, double date, double hours);
1215  Date(double year, double month, double date, double hours, double minutes);
1216  Date(double year, double month, double date, double hours, double minutes, double seconds);
1217  Date(double year, double month, double date, double hours, double minutes, double seconds, double ms);
1218  Date* get_prototype();
1219  static double parse(const String& s) [[cheerp::static]];
1220  static double UTC(double year, double month) [[cheerp::static]];
1221  static double UTC(double year, double month, double date) [[cheerp::static]];
1222  static double UTC(double year, double month, double date, double hours) [[cheerp::static]];
1223  static double UTC(double year, double month, double date, double hours, double minutes) [[cheerp::static]];
1224  static double UTC(double year, double month, double date, double hours, double minutes, double seconds) [[cheerp::static]];
1225  static double UTC(double year, double month, double date, double hours, double minutes, double seconds, double ms) [[cheerp::static]];
1226  static double now() [[cheerp::static]];
1227  };
1228 
1229  class RegExpMatchArray: public Array {
1230  public:
1231  double get_index();
1232  void set_index(double);
1233  String* get_input();
1234  void set_input(const String&);
1235  };
1236 
1237  class RegExpExecArray: public Array {
1238  public:
1239  double get_index();
1240  void set_index(double);
1241  String* get_input();
1242  void set_input(const String&);
1243  };
1244 
1245  class RegExp: public Object{
1246  public:
1247  RegExpExecArray* exec(const String& string);
1248  bool test(const String& string);
1249  String* get_source();
1250  bool get_global();
1251  bool get_ignoreCase();
1252  bool get_multiline();
1253  double get_lastIndex();
1254  void set_lastIndex(double);
1255  Object* compile();
1256  RegExp(RegExp* pattern);
1257  RegExp(const String& pattern);
1258  RegExp(const String& pattern, const String& flags);
1259  RegExp* get_prototype();
1260  String* get_$1();
1261  String* get_$2();
1262  String* get_$3();
1263  String* get_$4();
1264  String* get_$5();
1265  String* get_$6();
1266  String* get_$7();
1267  String* get_$8();
1268  String* get_$9();
1269  String* get_lastMatch();
1270  void set_lastMatch(const String&);
1271  };
1272 
1273  class Error: public Object{
1274  public:
1275  String* get_name();
1276  void set_name(const String&);
1277  String* get_message();
1278  void set_message(const String&);
1279  String* get_stack();
1280  void set_stack(const String&);
1281  Error();
1282  Error(const String& message);
1283  Error* get_prototype();
1284  };
1285 
1286  class EvalError: public Error {
1287  public:
1288  EvalError();
1289  EvalError(const String& message);
1290  EvalError* get_prototype();
1291  };
1292 
1293  class RangeError: public Error {
1294  public:
1295  RangeError();
1296  RangeError(const String& message);
1297  RangeError* get_prototype();
1298  };
1299 
1300  class ReferenceError: public Error {
1301  public:
1302  ReferenceError();
1303  ReferenceError(const String& message);
1304  ReferenceError* get_prototype();
1305  };
1306 
1307  class SyntaxError: public Error {
1308  public:
1309  SyntaxError();
1310  SyntaxError(const String& message);
1311  SyntaxError* get_prototype();
1312  };
1313 
1314  class TypeError: public Error {
1315  public:
1316  TypeError();
1317  TypeError(const String& message);
1318  TypeError* get_prototype();
1319  };
1320 
1321  class URIError: public Error {
1322  public:
1323  URIError();
1324  URIError(const String& message);
1325  URIError* get_prototype();
1326  };
1327 
1328  class JSON: public Object{
1329  public:
1330  Object* parse(const String& text);
1331  Object* parse(const String& text, EventListener* reviver);
1332  String* stringify(Object* value);
1333  String* stringify(Object* value, EventListener* replacer);
1334  String* stringify(Object* value, EventListener* replacer, const String& space);
1335  String* stringify(Object* value, EventListener* replacer, double space);
1336  String* stringify(Object* value, Array* replacer);
1337  String* stringify(Object* value, Array* replacer, const String& space);
1338  String* stringify(Object* value, Array* replacer, double space);
1339  };
1340 
1341  template<class T>
1342  class ConcatArray: public Object{
1343  public:
1344  double get_length();
1345  T*& operator[](int index)
1346  {
1347  return __builtin_cheerp_make_regular<T*>(this, 0)[index];
1348  }
1349  T* operator[](int index) const
1350  {
1351  return __builtin_cheerp_make_regular<T*>(this, 0)[index];
1352  }
1353  String* join();
1354  String* join(const String& separator);
1355  Array* slice();
1356  Array* slice(double start);
1357  Array* slice(double start, double end);
1358  };
1359 
1360  template<class T>
1361  class TypedPropertyDescriptor: public Object{
1362  public:
1363  bool get_enumerable();
1364  void set_enumerable(bool);
1365  bool get_configurable();
1366  void set_configurable(bool);
1367  bool get_writable();
1368  void set_writable(bool);
1369  T* get_value();
1370  void set_value(T*);
1371  EventListener* get_get();
1372  void set_get(EventListener*);
1373  EventListener* get_set();
1374  void set_set(EventListener*);
1375  };
1376 
1377  class Promise: public Object{
1378  public:
1379  Promise* then();
1380  Promise* then(EventListener* onfulfilled);
1381  Promise* then(EventListener* onfulfilled, EventListener* onrejected);
1382  Promise* _catch();
1383  Promise* _catch(EventListener* onrejected);
1384  };
1385 
1386  template<class T>
1387  class ThisType: public Object{
1388  public:
1389  };
1390 
1391  class ArrayBuffer: public Object{
1392  public:
1393  double get_byteLength();
1394  ArrayBuffer* slice(double begin);
1395  ArrayBuffer* slice(double begin, double end);
1396  ArrayBuffer* get_prototype();
1397  ArrayBuffer(double byteLength);
1398  static bool isView(Object* arg) [[cheerp::static]];
1399  };
1400 
1401  class ArrayBufferTypes: public Object{
1402  public:
1403  ArrayBuffer* get_ArrayBuffer();
1404  void set_ArrayBuffer(ArrayBuffer*);
1405  };
1406 
1407  class ArrayBufferView: public Object{
1408  public:
1409  ArrayBuffer* get_buffer();
1410  void set_buffer(ArrayBuffer*);
1411  double get_byteLength();
1412  void set_byteLength(double);
1413  double get_byteOffset();
1414  void set_byteOffset(double);
1415  };
1416 
1417  class DataView: public Object{
1418  public:
1419  ArrayBuffer* get_buffer();
1420  double get_byteLength();
1421  double get_byteOffset();
1422  double getFloat32(double byteOffset);
1423  double getFloat32(double byteOffset, bool littleEndian);
1424  double getFloat64(double byteOffset);
1425  double getFloat64(double byteOffset, bool littleEndian);
1426  double getInt8(double byteOffset);
1427  double getInt16(double byteOffset);
1428  double getInt16(double byteOffset, bool littleEndian);
1429  double getInt32(double byteOffset);
1430  double getInt32(double byteOffset, bool littleEndian);
1431  double getUint8(double byteOffset);
1432  double getUint16(double byteOffset);
1433  double getUint16(double byteOffset, bool littleEndian);
1434  double getUint32(double byteOffset);
1435  double getUint32(double byteOffset, bool littleEndian);
1436  void setFloat32(double byteOffset, double value);
1437  void setFloat32(double byteOffset, double value, bool littleEndian);
1438  void setFloat64(double byteOffset, double value);
1439  void setFloat64(double byteOffset, double value, bool littleEndian);
1440  void setInt8(double byteOffset, double value);
1441  void setInt16(double byteOffset, double value);
1442  void setInt16(double byteOffset, double value, bool littleEndian);
1443  void setInt32(double byteOffset, double value);
1444  void setInt32(double byteOffset, double value, bool littleEndian);
1445  void setUint8(double byteOffset, double value);
1446  void setUint16(double byteOffset, double value);
1447  void setUint16(double byteOffset, double value, bool littleEndian);
1448  void setUint32(double byteOffset, double value);
1449  void setUint32(double byteOffset, double value, bool littleEndian);
1450  template<class ArrayBufferLike> DataView(ArrayBufferLike* buffer);
1451  template<class ArrayBufferLike> DataView(ArrayBufferLike* buffer, double byteOffset);
1452  template<class ArrayBufferLike> DataView(ArrayBufferLike* buffer, double byteOffset, double byteLength);
1453  };
1454 
1455  class Int8Array: public ArrayBufferView {
1456  public:
1457  Object* copyWithin(double target, double start);
1458  Object* copyWithin(double target, double start, double end);
1459  bool every(EventListener* callbackfn);
1460  bool every(EventListener* callbackfn, Object* thisArg);
1461  Object* fill(double value);
1462  Object* fill(double value, double start);
1463  Object* fill(double value, double start, double end);
1464  Int8Array* filter(EventListener* callbackfn);
1465  Int8Array* filter(EventListener* callbackfn, Object* thisArg);
1466  double find(EventListener* predicate);
1467  double find(EventListener* predicate, Object* thisArg);
1468  double findIndex(EventListener* predicate);
1469  double findIndex(EventListener* predicate, Object* thisArg);
1470  void forEach(EventListener* callbackfn);
1471  void forEach(EventListener* callbackfn, Object* thisArg);
1472  double indexOf(double searchElement);
1473  double indexOf(double searchElement, double fromIndex);
1474  String* join();
1475  String* join(const String& separator);
1476  double lastIndexOf(double searchElement);
1477  double lastIndexOf(double searchElement, double fromIndex);
1478  double get_length();
1479  Int8Array* map(EventListener* callbackfn);
1480  Int8Array* map(EventListener* callbackfn, Object* thisArg);
1481  double reduce(EventListener* callbackfn);
1482  double reduce(EventListener* callbackfn, double initialValue);
1483  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1484  double reduceRight(EventListener* callbackfn);
1485  double reduceRight(EventListener* callbackfn, double initialValue);
1486  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1487  Int8Array* reverse();
1488  template<class ArrayLike> void set(ArrayLike* array);
1489  template<class ArrayLike> void set(ArrayLike* array, double offset);
1490  Int8Array* slice();
1491  Int8Array* slice(double start);
1492  Int8Array* slice(double start, double end);
1493  bool some(EventListener* callbackfn);
1494  bool some(EventListener* callbackfn, Object* thisArg);
1495  Object* sort();
1496  Object* sort(EventListener* compareFn);
1497  Int8Array* subarray(double begin);
1498  Int8Array* subarray(double begin, double end);
1499  String* toLocaleString();
1500  String* toString();
1501  char& operator[](int index)
1502  {
1503  return __builtin_cheerp_make_regular<char>(this, 0)[index];
1504  }
1505  char operator[](int index) const
1506  {
1507  return __builtin_cheerp_make_regular<char>(this, 0)[index];
1508  }
1509  Int8Array* get_prototype();
1510  Int8Array(double length);
1511  template<class ArrayLike> Int8Array(ArrayLike* arrayOrArrayBuffer);
1512  template<class ArrayBufferLike> Int8Array(ArrayBufferLike* buffer, double byteOffset);
1513  template<class ArrayBufferLike> Int8Array(ArrayBufferLike* buffer, double byteOffset, double length);
1514  double get_BYTES_PER_ELEMENT();
1515  template<typename... Args> static Int8Array* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
1516  static Int8Array* of() [[cheerp::static]];
1517  template<class ArrayLike> static Int8Array* from(ArrayLike* arrayLike) [[cheerp::static]];
1518  template<class ArrayLike> static Int8Array* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
1519  template<class ArrayLike> static Int8Array* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
1520  };
1521 
1522  class Uint8Array: public ArrayBufferView {
1523  public:
1524  Object* copyWithin(double target, double start);
1525  Object* copyWithin(double target, double start, double end);
1526  bool every(EventListener* callbackfn);
1527  bool every(EventListener* callbackfn, Object* thisArg);
1528  Object* fill(double value);
1529  Object* fill(double value, double start);
1530  Object* fill(double value, double start, double end);
1531  Uint8Array* filter(EventListener* callbackfn);
1532  Uint8Array* filter(EventListener* callbackfn, Object* thisArg);
1533  double find(EventListener* predicate);
1534  double find(EventListener* predicate, Object* thisArg);
1535  double findIndex(EventListener* predicate);
1536  double findIndex(EventListener* predicate, Object* thisArg);
1537  void forEach(EventListener* callbackfn);
1538  void forEach(EventListener* callbackfn, Object* thisArg);
1539  double indexOf(double searchElement);
1540  double indexOf(double searchElement, double fromIndex);
1541  String* join();
1542  String* join(const String& separator);
1543  double lastIndexOf(double searchElement);
1544  double lastIndexOf(double searchElement, double fromIndex);
1545  double get_length();
1546  Uint8Array* map(EventListener* callbackfn);
1547  Uint8Array* map(EventListener* callbackfn, Object* thisArg);
1548  double reduce(EventListener* callbackfn);
1549  double reduce(EventListener* callbackfn, double initialValue);
1550  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1551  double reduceRight(EventListener* callbackfn);
1552  double reduceRight(EventListener* callbackfn, double initialValue);
1553  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1554  Uint8Array* reverse();
1555  template<class ArrayLike> void set(ArrayLike* array);
1556  template<class ArrayLike> void set(ArrayLike* array, double offset);
1557  Uint8Array* slice();
1558  Uint8Array* slice(double start);
1559  Uint8Array* slice(double start, double end);
1560  bool some(EventListener* callbackfn);
1561  bool some(EventListener* callbackfn, Object* thisArg);
1562  Object* sort();
1563  Object* sort(EventListener* compareFn);
1564  Uint8Array* subarray(double begin);
1565  Uint8Array* subarray(double begin, double end);
1566  String* toLocaleString();
1567  String* toString();
1568  unsigned char& operator[](int index)
1569  {
1570  return __builtin_cheerp_make_regular<unsigned char>(this, 0)[index];
1571  }
1572  unsigned char operator[](int index) const
1573  {
1574  return __builtin_cheerp_make_regular<unsigned char>(this, 0)[index];
1575  }
1576  Uint8Array* get_prototype();
1577  Uint8Array(double length);
1578  template<class ArrayLike> Uint8Array(ArrayLike* arrayOrArrayBuffer);
1579  template<class ArrayBufferLike> Uint8Array(ArrayBufferLike* buffer, double byteOffset);
1580  template<class ArrayBufferLike> Uint8Array(ArrayBufferLike* buffer, double byteOffset, double length);
1581  double get_BYTES_PER_ELEMENT();
1582  template<typename... Args> static Uint8Array* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
1583  static Uint8Array* of() [[cheerp::static]];
1584  template<class ArrayLike> static Uint8Array* from(ArrayLike* arrayLike) [[cheerp::static]];
1585  template<class ArrayLike> static Uint8Array* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
1586  template<class ArrayLike> static Uint8Array* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
1587  };
1588 
1590  public:
1591  Object* copyWithin(double target, double start);
1592  Object* copyWithin(double target, double start, double end);
1593  bool every(EventListener* callbackfn);
1594  bool every(EventListener* callbackfn, Object* thisArg);
1595  Object* fill(double value);
1596  Object* fill(double value, double start);
1597  Object* fill(double value, double start, double end);
1598  Uint8ClampedArray* filter(EventListener* callbackfn);
1599  Uint8ClampedArray* filter(EventListener* callbackfn, Object* thisArg);
1600  double find(EventListener* predicate);
1601  double find(EventListener* predicate, Object* thisArg);
1602  double findIndex(EventListener* predicate);
1603  double findIndex(EventListener* predicate, Object* thisArg);
1604  void forEach(EventListener* callbackfn);
1605  void forEach(EventListener* callbackfn, Object* thisArg);
1606  double indexOf(double searchElement);
1607  double indexOf(double searchElement, double fromIndex);
1608  String* join();
1609  String* join(const String& separator);
1610  double lastIndexOf(double searchElement);
1611  double lastIndexOf(double searchElement, double fromIndex);
1612  double get_length();
1613  Uint8ClampedArray* map(EventListener* callbackfn);
1614  Uint8ClampedArray* map(EventListener* callbackfn, Object* thisArg);
1615  double reduce(EventListener* callbackfn);
1616  double reduce(EventListener* callbackfn, double initialValue);
1617  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1618  double reduceRight(EventListener* callbackfn);
1619  double reduceRight(EventListener* callbackfn, double initialValue);
1620  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1621  Uint8ClampedArray* reverse();
1622  template<class ArrayLike> void set(ArrayLike* array);
1623  template<class ArrayLike> void set(ArrayLike* array, double offset);
1624  Uint8ClampedArray* slice();
1625  Uint8ClampedArray* slice(double start);
1626  Uint8ClampedArray* slice(double start, double end);
1627  bool some(EventListener* callbackfn);
1628  bool some(EventListener* callbackfn, Object* thisArg);
1629  Object* sort();
1630  Object* sort(EventListener* compareFn);
1631  Uint8ClampedArray* subarray(double begin);
1632  Uint8ClampedArray* subarray(double begin, double end);
1633  String* toLocaleString();
1634  String* toString();
1635  double& operator[](int index)
1636  {
1637  return __builtin_cheerp_make_regular<double>(this, 0)[index];
1638  }
1639  double operator[](int index) const
1640  {
1641  return __builtin_cheerp_make_regular<double>(this, 0)[index];
1642  }
1643  Uint8ClampedArray* get_prototype();
1644  Uint8ClampedArray(double length);
1645  template<class ArrayLike> Uint8ClampedArray(ArrayLike* arrayOrArrayBuffer);
1646  template<class ArrayBufferLike> Uint8ClampedArray(ArrayBufferLike* buffer, double byteOffset);
1647  template<class ArrayBufferLike> Uint8ClampedArray(ArrayBufferLike* buffer, double byteOffset, double length);
1648  double get_BYTES_PER_ELEMENT();
1649  template<typename... Args> static Uint8ClampedArray* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
1650  static Uint8ClampedArray* of() [[cheerp::static]];
1651  template<class ArrayLike> static Uint8ClampedArray* from(ArrayLike* arrayLike) [[cheerp::static]];
1652  template<class ArrayLike> static Uint8ClampedArray* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
1653  template<class ArrayLike> static Uint8ClampedArray* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
1654  };
1655 
1656  class Int16Array: public ArrayBufferView {
1657  public:
1658  Object* copyWithin(double target, double start);
1659  Object* copyWithin(double target, double start, double end);
1660  bool every(EventListener* callbackfn);
1661  bool every(EventListener* callbackfn, Object* thisArg);
1662  Object* fill(double value);
1663  Object* fill(double value, double start);
1664  Object* fill(double value, double start, double end);
1665  Int16Array* filter(EventListener* callbackfn);
1666  Int16Array* filter(EventListener* callbackfn, Object* thisArg);
1667  double find(EventListener* predicate);
1668  double find(EventListener* predicate, Object* thisArg);
1669  double findIndex(EventListener* predicate);
1670  double findIndex(EventListener* predicate, Object* thisArg);
1671  void forEach(EventListener* callbackfn);
1672  void forEach(EventListener* callbackfn, Object* thisArg);
1673  double indexOf(double searchElement);
1674  double indexOf(double searchElement, double fromIndex);
1675  String* join();
1676  String* join(const String& separator);
1677  double lastIndexOf(double searchElement);
1678  double lastIndexOf(double searchElement, double fromIndex);
1679  double get_length();
1680  Int16Array* map(EventListener* callbackfn);
1681  Int16Array* map(EventListener* callbackfn, Object* thisArg);
1682  double reduce(EventListener* callbackfn);
1683  double reduce(EventListener* callbackfn, double initialValue);
1684  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1685  double reduceRight(EventListener* callbackfn);
1686  double reduceRight(EventListener* callbackfn, double initialValue);
1687  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1688  Int16Array* reverse();
1689  template<class ArrayLike> void set(ArrayLike* array);
1690  template<class ArrayLike> void set(ArrayLike* array, double offset);
1691  Int16Array* slice();
1692  Int16Array* slice(double start);
1693  Int16Array* slice(double start, double end);
1694  bool some(EventListener* callbackfn);
1695  bool some(EventListener* callbackfn, Object* thisArg);
1696  Object* sort();
1697  Object* sort(EventListener* compareFn);
1698  Int16Array* subarray(double begin);
1699  Int16Array* subarray(double begin, double end);
1700  String* toLocaleString();
1701  String* toString();
1702  short& operator[](int index)
1703  {
1704  return __builtin_cheerp_make_regular<short>(this, 0)[index];
1705  }
1706  short operator[](int index) const
1707  {
1708  return __builtin_cheerp_make_regular<short>(this, 0)[index];
1709  }
1710  Int16Array* get_prototype();
1711  Int16Array(double length);
1712  template<class ArrayLike> Int16Array(ArrayLike* arrayOrArrayBuffer);
1713  template<class ArrayBufferLike> Int16Array(ArrayBufferLike* buffer, double byteOffset);
1714  template<class ArrayBufferLike> Int16Array(ArrayBufferLike* buffer, double byteOffset, double length);
1715  double get_BYTES_PER_ELEMENT();
1716  template<typename... Args> static Int16Array* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
1717  static Int16Array* of() [[cheerp::static]];
1718  template<class ArrayLike> static Int16Array* from(ArrayLike* arrayLike) [[cheerp::static]];
1719  template<class ArrayLike> static Int16Array* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
1720  template<class ArrayLike> static Int16Array* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
1721  };
1722 
1724  public:
1725  Object* copyWithin(double target, double start);
1726  Object* copyWithin(double target, double start, double end);
1727  bool every(EventListener* callbackfn);
1728  bool every(EventListener* callbackfn, Object* thisArg);
1729  Object* fill(double value);
1730  Object* fill(double value, double start);
1731  Object* fill(double value, double start, double end);
1732  Uint16Array* filter(EventListener* callbackfn);
1733  Uint16Array* filter(EventListener* callbackfn, Object* thisArg);
1734  double find(EventListener* predicate);
1735  double find(EventListener* predicate, Object* thisArg);
1736  double findIndex(EventListener* predicate);
1737  double findIndex(EventListener* predicate, Object* thisArg);
1738  void forEach(EventListener* callbackfn);
1739  void forEach(EventListener* callbackfn, Object* thisArg);
1740  double indexOf(double searchElement);
1741  double indexOf(double searchElement, double fromIndex);
1742  String* join();
1743  String* join(const String& separator);
1744  double lastIndexOf(double searchElement);
1745  double lastIndexOf(double searchElement, double fromIndex);
1746  double get_length();
1747  Uint16Array* map(EventListener* callbackfn);
1748  Uint16Array* map(EventListener* callbackfn, Object* thisArg);
1749  double reduce(EventListener* callbackfn);
1750  double reduce(EventListener* callbackfn, double initialValue);
1751  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1752  double reduceRight(EventListener* callbackfn);
1753  double reduceRight(EventListener* callbackfn, double initialValue);
1754  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1755  Uint16Array* reverse();
1756  template<class ArrayLike> void set(ArrayLike* array);
1757  template<class ArrayLike> void set(ArrayLike* array, double offset);
1758  Uint16Array* slice();
1759  Uint16Array* slice(double start);
1760  Uint16Array* slice(double start, double end);
1761  bool some(EventListener* callbackfn);
1762  bool some(EventListener* callbackfn, Object* thisArg);
1763  Object* sort();
1764  Object* sort(EventListener* compareFn);
1765  Uint16Array* subarray(double begin);
1766  Uint16Array* subarray(double begin, double end);
1767  String* toLocaleString();
1768  String* toString();
1769  unsigned short& operator[](int index)
1770  {
1771  return __builtin_cheerp_make_regular<unsigned short>(this, 0)[index];
1772  }
1773  unsigned short operator[](int index) const
1774  {
1775  return __builtin_cheerp_make_regular<unsigned short>(this, 0)[index];
1776  }
1777  Uint16Array* get_prototype();
1778  Uint16Array(double length);
1779  template<class ArrayLike> Uint16Array(ArrayLike* arrayOrArrayBuffer);
1780  template<class ArrayBufferLike> Uint16Array(ArrayBufferLike* buffer, double byteOffset);
1781  template<class ArrayBufferLike> Uint16Array(ArrayBufferLike* buffer, double byteOffset, double length);
1782  double get_BYTES_PER_ELEMENT();
1783  template<typename... Args> static Uint16Array* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
1784  static Uint16Array* of() [[cheerp::static]];
1785  template<class ArrayLike> static Uint16Array* from(ArrayLike* arrayLike) [[cheerp::static]];
1786  template<class ArrayLike> static Uint16Array* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
1787  template<class ArrayLike> static Uint16Array* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
1788  };
1789 
1790  class Int32Array: public ArrayBufferView {
1791  public:
1792  Object* copyWithin(double target, double start);
1793  Object* copyWithin(double target, double start, double end);
1794  bool every(EventListener* callbackfn);
1795  bool every(EventListener* callbackfn, Object* thisArg);
1796  Object* fill(double value);
1797  Object* fill(double value, double start);
1798  Object* fill(double value, double start, double end);
1799  Int32Array* filter(EventListener* callbackfn);
1800  Int32Array* filter(EventListener* callbackfn, Object* thisArg);
1801  double find(EventListener* predicate);
1802  double find(EventListener* predicate, Object* thisArg);
1803  double findIndex(EventListener* predicate);
1804  double findIndex(EventListener* predicate, Object* thisArg);
1805  void forEach(EventListener* callbackfn);
1806  void forEach(EventListener* callbackfn, Object* thisArg);
1807  double indexOf(double searchElement);
1808  double indexOf(double searchElement, double fromIndex);
1809  String* join();
1810  String* join(const String& separator);
1811  double lastIndexOf(double searchElement);
1812  double lastIndexOf(double searchElement, double fromIndex);
1813  double get_length();
1814  Int32Array* map(EventListener* callbackfn);
1815  Int32Array* map(EventListener* callbackfn, Object* thisArg);
1816  double reduce(EventListener* callbackfn);
1817  double reduce(EventListener* callbackfn, double initialValue);
1818  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1819  double reduceRight(EventListener* callbackfn);
1820  double reduceRight(EventListener* callbackfn, double initialValue);
1821  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1822  Int32Array* reverse();
1823  template<class ArrayLike> void set(ArrayLike* array);
1824  template<class ArrayLike> void set(ArrayLike* array, double offset);
1825  Int32Array* slice();
1826  Int32Array* slice(double start);
1827  Int32Array* slice(double start, double end);
1828  bool some(EventListener* callbackfn);
1829  bool some(EventListener* callbackfn, Object* thisArg);
1830  Object* sort();
1831  Object* sort(EventListener* compareFn);
1832  Int32Array* subarray(double begin);
1833  Int32Array* subarray(double begin, double end);
1834  String* toLocaleString();
1835  String* toString();
1836  int& operator[](int index)
1837  {
1838  return __builtin_cheerp_make_regular<int>(this, 0)[index];
1839  }
1840  int operator[](int index) const
1841  {
1842  return __builtin_cheerp_make_regular<int>(this, 0)[index];
1843  }
1844  Int32Array* get_prototype();
1845  Int32Array(double length);
1846  template<class ArrayLike> Int32Array(ArrayLike* arrayOrArrayBuffer);
1847  template<class ArrayBufferLike> Int32Array(ArrayBufferLike* buffer, double byteOffset);
1848  template<class ArrayBufferLike> Int32Array(ArrayBufferLike* buffer, double byteOffset, double length);
1849  double get_BYTES_PER_ELEMENT();
1850  template<typename... Args> static Int32Array* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
1851  static Int32Array* of() [[cheerp::static]];
1852  template<class ArrayLike> static Int32Array* from(ArrayLike* arrayLike) [[cheerp::static]];
1853  template<class ArrayLike> static Int32Array* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
1854  template<class ArrayLike> static Int32Array* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
1855  };
1856 
1858  public:
1859  Object* copyWithin(double target, double start);
1860  Object* copyWithin(double target, double start, double end);
1861  bool every(EventListener* callbackfn);
1862  bool every(EventListener* callbackfn, Object* thisArg);
1863  Object* fill(double value);
1864  Object* fill(double value, double start);
1865  Object* fill(double value, double start, double end);
1866  Uint32Array* filter(EventListener* callbackfn);
1867  Uint32Array* filter(EventListener* callbackfn, Object* thisArg);
1868  double find(EventListener* predicate);
1869  double find(EventListener* predicate, Object* thisArg);
1870  double findIndex(EventListener* predicate);
1871  double findIndex(EventListener* predicate, Object* thisArg);
1872  void forEach(EventListener* callbackfn);
1873  void forEach(EventListener* callbackfn, Object* thisArg);
1874  double indexOf(double searchElement);
1875  double indexOf(double searchElement, double fromIndex);
1876  String* join();
1877  String* join(const String& separator);
1878  double lastIndexOf(double searchElement);
1879  double lastIndexOf(double searchElement, double fromIndex);
1880  double get_length();
1881  Uint32Array* map(EventListener* callbackfn);
1882  Uint32Array* map(EventListener* callbackfn, Object* thisArg);
1883  double reduce(EventListener* callbackfn);
1884  double reduce(EventListener* callbackfn, double initialValue);
1885  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1886  double reduceRight(EventListener* callbackfn);
1887  double reduceRight(EventListener* callbackfn, double initialValue);
1888  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1889  Uint32Array* reverse();
1890  template<class ArrayLike> void set(ArrayLike* array);
1891  template<class ArrayLike> void set(ArrayLike* array, double offset);
1892  Uint32Array* slice();
1893  Uint32Array* slice(double start);
1894  Uint32Array* slice(double start, double end);
1895  bool some(EventListener* callbackfn);
1896  bool some(EventListener* callbackfn, Object* thisArg);
1897  Object* sort();
1898  Object* sort(EventListener* compareFn);
1899  Uint32Array* subarray(double begin);
1900  Uint32Array* subarray(double begin, double end);
1901  String* toLocaleString();
1902  String* toString();
1903  unsigned int& operator[](int index)
1904  {
1905  return __builtin_cheerp_make_regular<unsigned int>(this, 0)[index];
1906  }
1907  unsigned int operator[](int index) const
1908  {
1909  return __builtin_cheerp_make_regular<unsigned int>(this, 0)[index];
1910  }
1911  Uint32Array* get_prototype();
1912  Uint32Array(double length);
1913  template<class ArrayLike> Uint32Array(ArrayLike* arrayOrArrayBuffer);
1914  template<class ArrayBufferLike> Uint32Array(ArrayBufferLike* buffer, double byteOffset);
1915  template<class ArrayBufferLike> Uint32Array(ArrayBufferLike* buffer, double byteOffset, double length);
1916  double get_BYTES_PER_ELEMENT();
1917  template<typename... Args> static Uint32Array* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
1918  static Uint32Array* of() [[cheerp::static]];
1919  template<class ArrayLike> static Uint32Array* from(ArrayLike* arrayLike) [[cheerp::static]];
1920  template<class ArrayLike> static Uint32Array* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
1921  template<class ArrayLike> static Uint32Array* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
1922  };
1923 
1925  public:
1926  Object* copyWithin(double target, double start);
1927  Object* copyWithin(double target, double start, double end);
1928  bool every(EventListener* callbackfn);
1929  bool every(EventListener* callbackfn, Object* thisArg);
1930  Object* fill(double value);
1931  Object* fill(double value, double start);
1932  Object* fill(double value, double start, double end);
1933  Float32Array* filter(EventListener* callbackfn);
1934  Float32Array* filter(EventListener* callbackfn, Object* thisArg);
1935  double find(EventListener* predicate);
1936  double find(EventListener* predicate, Object* thisArg);
1937  double findIndex(EventListener* predicate);
1938  double findIndex(EventListener* predicate, Object* thisArg);
1939  void forEach(EventListener* callbackfn);
1940  void forEach(EventListener* callbackfn, Object* thisArg);
1941  double indexOf(double searchElement);
1942  double indexOf(double searchElement, double fromIndex);
1943  String* join();
1944  String* join(const String& separator);
1945  double lastIndexOf(double searchElement);
1946  double lastIndexOf(double searchElement, double fromIndex);
1947  double get_length();
1948  Float32Array* map(EventListener* callbackfn);
1949  Float32Array* map(EventListener* callbackfn, Object* thisArg);
1950  double reduce(EventListener* callbackfn);
1951  double reduce(EventListener* callbackfn, double initialValue);
1952  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
1953  double reduceRight(EventListener* callbackfn);
1954  double reduceRight(EventListener* callbackfn, double initialValue);
1955  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
1956  Float32Array* reverse();
1957  template<class ArrayLike> void set(ArrayLike* array);
1958  template<class ArrayLike> void set(ArrayLike* array, double offset);
1959  Float32Array* slice();
1960  Float32Array* slice(double start);
1961  Float32Array* slice(double start, double end);
1962  bool some(EventListener* callbackfn);
1963  bool some(EventListener* callbackfn, Object* thisArg);
1964  Object* sort();
1965  Object* sort(EventListener* compareFn);
1966  Float32Array* subarray(double begin);
1967  Float32Array* subarray(double begin, double end);
1968  String* toLocaleString();
1969  String* toString();
1970  float& operator[](int index)
1971  {
1972  return __builtin_cheerp_make_regular<float>(this, 0)[index];
1973  }
1974  float operator[](int index) const
1975  {
1976  return __builtin_cheerp_make_regular<float>(this, 0)[index];
1977  }
1978  Float32Array* get_prototype();
1979  Float32Array(double length);
1980  template<class ArrayLike> Float32Array(ArrayLike* arrayOrArrayBuffer);
1981  template<class ArrayBufferLike> Float32Array(ArrayBufferLike* buffer, double byteOffset);
1982  template<class ArrayBufferLike> Float32Array(ArrayBufferLike* buffer, double byteOffset, double length);
1983  double get_BYTES_PER_ELEMENT();
1984  template<typename... Args> static Float32Array* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
1985  static Float32Array* of() [[cheerp::static]];
1986  template<class ArrayLike> static Float32Array* from(ArrayLike* arrayLike) [[cheerp::static]];
1987  template<class ArrayLike> static Float32Array* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
1988  template<class ArrayLike> static Float32Array* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
1989  };
1990 
1992  public:
1993  Object* copyWithin(double target, double start);
1994  Object* copyWithin(double target, double start, double end);
1995  bool every(EventListener* callbackfn);
1996  bool every(EventListener* callbackfn, Object* thisArg);
1997  Object* fill(double value);
1998  Object* fill(double value, double start);
1999  Object* fill(double value, double start, double end);
2000  Float64Array* filter(EventListener* callbackfn);
2001  Float64Array* filter(EventListener* callbackfn, Object* thisArg);
2002  double find(EventListener* predicate);
2003  double find(EventListener* predicate, Object* thisArg);
2004  double findIndex(EventListener* predicate);
2005  double findIndex(EventListener* predicate, Object* thisArg);
2006  void forEach(EventListener* callbackfn);
2007  void forEach(EventListener* callbackfn, Object* thisArg);
2008  double indexOf(double searchElement);
2009  double indexOf(double searchElement, double fromIndex);
2010  String* join();
2011  String* join(const String& separator);
2012  double lastIndexOf(double searchElement);
2013  double lastIndexOf(double searchElement, double fromIndex);
2014  double get_length();
2015  Float64Array* map(EventListener* callbackfn);
2016  Float64Array* map(EventListener* callbackfn, Object* thisArg);
2017  double reduce(EventListener* callbackfn);
2018  double reduce(EventListener* callbackfn, double initialValue);
2019  template<class U> U* reduce(EventListener* callbackfn, U* initialValue);
2020  double reduceRight(EventListener* callbackfn);
2021  double reduceRight(EventListener* callbackfn, double initialValue);
2022  template<class U> U* reduceRight(EventListener* callbackfn, U* initialValue);
2023  Float64Array* reverse();
2024  template<class ArrayLike> void set(ArrayLike* array);
2025  template<class ArrayLike> void set(ArrayLike* array, double offset);
2026  Float64Array* slice();
2027  Float64Array* slice(double start);
2028  Float64Array* slice(double start, double end);
2029  bool some(EventListener* callbackfn);
2030  bool some(EventListener* callbackfn, Object* thisArg);
2031  Object* sort();
2032  Object* sort(EventListener* compareFn);
2033  Float64Array* subarray(double begin);
2034  Float64Array* subarray(double begin, double end);
2035  String* toLocaleString();
2036  String* toString();
2037  double& operator[](int index)
2038  {
2039  return __builtin_cheerp_make_regular<double>(this, 0)[index];
2040  }
2041  double operator[](int index) const
2042  {
2043  return __builtin_cheerp_make_regular<double>(this, 0)[index];
2044  }
2045  Float64Array* get_prototype();
2046  Float64Array(double length);
2047  template<class ArrayLike> Float64Array(ArrayLike* arrayOrArrayBuffer);
2048  template<class ArrayBufferLike> Float64Array(ArrayBufferLike* buffer, double byteOffset);
2049  template<class ArrayBufferLike> Float64Array(ArrayBufferLike* buffer, double byteOffset, double length);
2050  double get_BYTES_PER_ELEMENT();
2051  template<typename... Args> static Float64Array* of(Args&&... items) { return of(static_cast<double>(static_cast<Args&&>(items))...); }
2052  static Float64Array* of() [[cheerp::static]];
2053  template<class ArrayLike> static Float64Array* from(ArrayLike* arrayLike) [[cheerp::static]];
2054  template<class ArrayLike> static Float64Array* from(ArrayLike* arrayLike, EventListener* mapfn) [[cheerp::static]];
2055  template<class ArrayLike> static Float64Array* from(ArrayLike* arrayLike, EventListener* mapfn, Object* thisArg) [[cheerp::static]];
2056  };
2057 
2058  class Account: public Object{
2059  public:
2060  String* get_displayName();
2061  void set_displayName(const String&);
2062  String* get_id();
2063  void set_id(const String&);
2064  String* get_imageURL();
2065  void set_imageURL(const String&);
2066  String* get_name();
2067  void set_name(const String&);
2068  String* get_rpDisplayName();
2069  void set_rpDisplayName(const String&);
2070  };
2071 
2073  public:
2074  bool get_capture();
2075  void set_capture(bool);
2076  };
2077 
2079  public:
2080  bool get_once();
2081  void set_once(bool);
2082  bool get_passive();
2083  void set_passive(bool);
2084  };
2085 
2086  class Algorithm: public Object{
2087  public:
2088  String* get_name();
2089  void set_name(const String&);
2090  };
2091 
2092  class AesCbcParams: public Algorithm {
2093  public:
2094  Int8Array* get_iv();
2095  void set_iv(Int8Array*);
2096  };
2097 
2098  class AesCtrParams: public Algorithm {
2099  public:
2100  Int8Array* get_counter();
2101  void set_counter(Int8Array*);
2102  double get_length();
2103  void set_length(double);
2104  };
2105 
2107  public:
2108  double get_length();
2109  void set_length(double);
2110  };
2111 
2112  class AesGcmParams: public Algorithm {
2113  public:
2114  Int8Array* get_additionalData();
2115  void set_additionalData(Int8Array*);
2116  Int8Array* get_iv();
2117  void set_iv(Int8Array*);
2118  double get_tagLength();
2119  void set_tagLength(double);
2120  };
2121 
2122  class KeyAlgorithm: public Object{
2123  public:
2124  String* get_name();
2125  void set_name(const String&);
2126  };
2127 
2129  public:
2130  double get_length();
2131  void set_length(double);
2132  };
2133 
2134  class AesKeyGenParams: public Algorithm {
2135  public:
2136  double get_length();
2137  void set_length(double);
2138  };
2139 
2140  class AudioNodeOptions: public Object{
2141  public:
2142  double get_channelCount();
2143  void set_channelCount(double);
2144  String* get_channelCountMode();
2145  void set_channelCountMode(const String&);
2146  String* get_channelInterpretation();
2147  void set_channelInterpretation(const String&);
2148  };
2149 
2151  public:
2152  double get_fftSize();
2153  void set_fftSize(double);
2154  double get_maxDecibels();
2155  void set_maxDecibels(double);
2156  double get_minDecibels();
2157  void set_minDecibels(double);
2158  double get_smoothingTimeConstant();
2159  void set_smoothingTimeConstant(double);
2160  };
2161 
2162  class EventInit: public Object{
2163  public:
2164  bool get_bubbles();
2165  void set_bubbles(bool);
2166  bool get_cancelable();
2167  void set_cancelable(bool);
2168  bool get_scoped();
2169  void set_scoped(bool);
2170  };
2171 
2173  public:
2174  String* get_animationName();
2175  void set_animationName(const String&);
2176  double get_elapsedTime();
2177  void set_elapsedTime(double);
2178  };
2179 
2180  class AssertionOptions: public Object{
2181  public:
2182  Array* get_allowList();
2183  void set_allowList(Array*);
2184  WebAuthnExtensions* get_extensions();
2185  void set_extensions(WebAuthnExtensions*);
2186  String* get_rpId();
2187  void set_rpId(const String&);
2188  double get_timeoutSeconds();
2189  void set_timeoutSeconds(double);
2190  };
2191 
2193  public:
2194  double get_length();
2195  void set_length(double);
2196  double get_numberOfChannels();
2197  void set_numberOfChannels(double);
2198  double get_sampleRate();
2199  void set_sampleRate(double);
2200  };
2201 
2203  public:
2204  AudioBuffer* get_buffer();
2205  void set_buffer(AudioBuffer*);
2206  double get_detune();
2207  void set_detune(double);
2208  bool get_loop();
2209  void set_loop(bool);
2210  double get_loopEnd();
2211  void set_loopEnd(double);
2212  double get_loopStart();
2213  void set_loopStart(double);
2214  double get_playbackRate();
2215  void set_playbackRate(double);
2216  };
2217 
2218  class AudioContextInfo: public Object{
2219  public:
2220  double get_currentTime();
2221  void set_currentTime(double);
2222  double get_sampleRate();
2223  void set_sampleRate(double);
2224  };
2225 
2227  public:
2228  String* get_latencyHint();
2229  void set_latencyHint(const String&);
2230  double get_sampleRate();
2231  void set_sampleRate(double);
2232  };
2233 
2235  public:
2236  double get_defaultValue();
2237  void set_defaultValue(double);
2238  double get_maxValue();
2239  void set_maxValue(double);
2240  double get_minValue();
2241  void set_minValue(double);
2242  String* get_name();
2243  void set_name(const String&);
2244  };
2245 
2247  public:
2248  AudioBuffer* get_inputBuffer();
2249  void set_inputBuffer(AudioBuffer*);
2250  AudioBuffer* get_outputBuffer();
2251  void set_outputBuffer(AudioBuffer*);
2252  double get_playbackTime();
2253  void set_playbackTime(double);
2254  };
2255 
2256  class AudioTimestamp: public Object{
2257  public:
2258  double get_contextTime();
2259  void set_contextTime(double);
2260  double get_performanceTime();
2261  void set_performanceTime(double);
2262  };
2263 
2265  public:
2266  double get_Q();
2267  double get_detune();
2268  void set_detune(double);
2269  double get_frequency();
2270  void set_frequency(double);
2271  double get_gain();
2272  void set_gain(double);
2273  String* get_type();
2274  void set_type(const String&);
2275  };
2276 
2277  class ByteLengthChunk: public Object{
2278  public:
2279  double get_byteLength();
2280  void set_byteLength(double);
2281  };
2282 
2283  class CacheQueryOptions: public Object{
2284  public:
2285  String* get_cacheName();
2286  void set_cacheName(const String&);
2287  bool get_ignoreMethod();
2288  void set_ignoreMethod(bool);
2289  bool get_ignoreSearch();
2290  void set_ignoreSearch(bool);
2291  bool get_ignoreVary();
2292  void set_ignoreVary(bool);
2293  };
2294 
2296  public:
2297  double get_numberOfInputs();
2298  void set_numberOfInputs(double);
2299  };
2300 
2302  public:
2303  double get_numberOfOutputs();
2304  void set_numberOfOutputs(double);
2305  };
2306 
2307  class ClientData: public Object{
2308  public:
2309  String* get_challenge();
2310  void set_challenge(const String&);
2311  WebAuthnExtensions* get_extensions();
2312  void set_extensions(WebAuthnExtensions*);
2313  String* get_hashAlg();
2314  void set_hashAlg(const String&);
2315  String* get_origin();
2316  void set_origin(const String&);
2317  String* get_rpId();
2318  void set_rpId(const String&);
2319  String* get_tokenBinding();
2320  void set_tokenBinding(const String&);
2321  };
2322 
2324  public:
2325  bool get_includeReserved();
2326  void set_includeReserved(bool);
2327  bool get_includeUncontrolled();
2328  void set_includeUncontrolled(bool);
2329  String* get_type();
2330  void set_type(const String&);
2331  };
2332 
2333  class CloseEventInit: public EventInit {
2334  public:
2335  double get_code();
2336  void set_code(double);
2337  String* get_reason();
2338  void set_reason(const String&);
2339  bool get_wasClean();
2340  void set_wasClean(bool);
2341  };
2342 
2343  class UIEventInit: public EventInit {
2344  public:
2345  double get_detail();
2346  void set_detail(double);
2347  Window* get_view();
2348  void set_view(Window*);
2349  };
2350 
2352  public:
2353  String* get_data();
2354  void set_data(const String&);
2355  };
2356 
2358  public:
2359  String* get_domain();
2360  void set_domain(const String&);
2361  };
2362 
2364  public:
2365  Array* get_arrayOfDomainStrings();
2366  void set_arrayOfDomainStrings(Array*);
2367  };
2368 
2370  public:
2371  double get_offset();
2372  void set_offset(double);
2373  };
2374 
2376  public:
2377  bool get_exact();
2378  void set_exact(bool);
2379  bool get_ideal();
2380  void set_ideal(bool);
2381  };
2382 
2384  public:
2385  String* get_exact();
2386  void set_exact(const String&);
2387  String* get_ideal();
2388  void set_ideal(const String&);
2389  };
2390 
2391  class DoubleRange: public Object{
2392  public:
2393  double get_max();
2394  void set_max(double);
2395  double get_min();
2396  void set_min(double);
2397  };
2398 
2400  public:
2401  double get_exact();
2402  void set_exact(double);
2403  double get_ideal();
2404  void set_ideal(double);
2405  };
2406 
2407  class LongRange: public Object{
2408  public:
2409  double get_max();
2410  void set_max(double);
2411  double get_min();
2412  void set_min(double);
2413  };
2414 
2416  public:
2417  double get_exact();
2418  void set_exact(double);
2419  double get_ideal();
2420  void set_ideal(double);
2421  };
2422 
2424  public:
2425  Object* get_exact();
2426  void set_exact(Object*);
2427  Object* get_ideal();
2428  void set_ideal(Object*);
2429  };
2430 
2432  public:
2433  AudioBuffer* get_buffer();
2434  void set_buffer(AudioBuffer*);
2435  bool get_disableNormalization();
2436  void set_disableNormalization(bool);
2437  };
2438 
2439  template<class T>
2440  class CustomEventInit: public EventInit {
2441  public:
2442  T* get_detail();
2443  void set_detail(T*);
2444  };
2445 
2446  class DOMRectInit: public Object{
2447  public:
2448  double get_height();
2449  void set_height(double);
2450  double get_width();
2451  void set_width(double);
2452  double get_x();
2453  void set_x(double);
2454  double get_y();
2455  void set_y(double);
2456  };
2457 
2459  public:
2460  double get_delayTime();
2461  void set_delayTime(double);
2462  double get_maxDelayTime();
2463  void set_maxDelayTime(double);
2464  };
2465 
2467  public:
2468  double get_x();
2469  void set_x(double);
2470  double get_y();
2471  void set_y(double);
2472  double get_z();
2473  void set_z(double);
2474  };
2475 
2477  public:
2478  double get_value();
2479  void set_value(double);
2480  };
2481 
2483  public:
2484  DeviceAccelerationDict* get_acceleration();
2485  void set_acceleration(DeviceAccelerationDict*);
2486  DeviceAccelerationDict* get_accelerationIncludingGravity();
2487  void set_accelerationIncludingGravity(DeviceAccelerationDict*);
2488  double get_interval();
2489  void set_interval(double);
2490  DeviceRotationRateDict* get_rotationRate();
2491  void set_rotationRate(DeviceRotationRateDict*);
2492  };
2493 
2495  public:
2496  bool get_absolute();
2497  void set_absolute(bool);
2498  double get_alpha();
2499  void set_alpha(double);
2500  double get_beta();
2501  void set_beta(double);
2502  double get_gamma();
2503  void set_gamma(double);
2504  };
2505 
2507  public:
2508  double get_alpha();
2509  void set_alpha(double);
2510  double get_beta();
2511  void set_beta(double);
2512  double get_gamma();
2513  void set_gamma(double);
2514  };
2515 
2517  public:
2518  double get_attack();
2519  void set_attack(double);
2520  double get_knee();
2521  void set_knee(double);
2522  double get_ratio();
2523  void set_ratio(double);
2524  double get_release();
2525  void set_release(double);
2526  double get_threshold();
2527  void set_threshold(double);
2528  };
2529 
2531  public:
2532  String* get_namedCurve();
2533  void set_namedCurve(const String&);
2534  };
2535 
2536  class EcKeyGenParams: public Algorithm {
2537  public:
2538  String* get_namedCurve();
2539  void set_namedCurve(const String&);
2540  };
2541 
2543  public:
2544  String* get_namedCurve();
2545  void set_namedCurve(const String&);
2546  };
2547 
2549  public:
2550  CryptoKey* get_public();
2551  void set_public(CryptoKey*);
2552  };
2553 
2554  class EcdsaParams: public Algorithm {
2555  public:
2556  String* get_hash();
2557  void set_hash(const String&);
2558  };
2559 
2560  class ErrorEventInit: public EventInit {
2561  public:
2562  double get_colno();
2563  void set_colno(double);
2564  Object* get_error();
2565  void set_error(Object*);
2566  String* get_filename();
2567  void set_filename(const String&);
2568  double get_lineno();
2569  void set_lineno(double);
2570  String* get_message();
2571  void set_message(const String&);
2572  };
2573 
2575  public:
2576  bool get_altKey();
2577  void set_altKey(bool);
2578  bool get_ctrlKey();
2579  void set_ctrlKey(bool);
2580  bool get_metaKey();
2581  void set_metaKey(bool);
2582  bool get_modifierAltGraph();
2583  void set_modifierAltGraph(bool);
2584  bool get_modifierCapsLock();
2585  void set_modifierCapsLock(bool);
2586  bool get_modifierFn();
2587  void set_modifierFn(bool);
2588  bool get_modifierFnLock();
2589  void set_modifierFnLock(bool);
2590  bool get_modifierHyper();
2591  void set_modifierHyper(bool);
2592  bool get_modifierNumLock();
2593  void set_modifierNumLock(bool);
2594  bool get_modifierOS();
2595  void set_modifierOS(bool);
2596  bool get_modifierScrollLock();
2597  void set_modifierScrollLock(bool);
2598  bool get_modifierSuper();
2599  void set_modifierSuper(bool);
2600  bool get_modifierSymbol();
2601  void set_modifierSymbol(bool);
2602  bool get_modifierSymbolLock();
2603  void set_modifierSymbolLock(bool);
2604  bool get_shiftKey();
2605  void set_shiftKey(bool);
2606  };
2607 
2609  public:
2610  };
2611 
2613  public:
2614  Object* get_data();
2615  void set_data(Object*);
2616  String* get_lastEventId();
2617  void set_lastEventId(const String&);
2618  String* get_origin();
2619  void set_origin(const String&);
2620  Array* get_ports();
2621  void set_ports(Array*);
2622  Object* get_source();
2623  void set_source(Object*);
2624  };
2625 
2627  public:
2628  String* get_clientId();
2629  void set_clientId(const String&);
2630  Request* get_request();
2631  void set_request(Request*);
2632  String* get_reservedClientId();
2633  void set_reservedClientId(const String&);
2634  String* get_targetClientId();
2635  void set_targetClientId(const String&);
2636  };
2637 
2638  class FocusEventInit: public UIEventInit {
2639  public:
2640  EventTarget* get_relatedTarget();
2641  void set_relatedTarget(EventTarget*);
2642  };
2643 
2645  public:
2646  String* get_navigationReason();
2647  void set_navigationReason(const String&);
2648  double get_originHeight();
2649  void set_originHeight(double);
2650  double get_originLeft();
2651  void set_originLeft(double);
2652  double get_originTop();
2653  void set_originTop(double);
2654  double get_originWidth();
2655  void set_originWidth(double);
2656  };
2657 
2659  public:
2660  double get_originHeight();
2661  void set_originHeight(double);
2662  double get_originLeft();
2663  void set_originLeft(double);
2664  double get_originTop();
2665  void set_originTop(double);
2666  double get_originWidth();
2667  void set_originWidth(double);
2668  };
2669 
2671  public:
2672  double get_gain();
2673  void set_gain(double);
2674  };
2675 
2676  class GamepadEventInit: public EventInit {
2677  public:
2678  Gamepad* get_gamepad();
2679  void set_gamepad(Gamepad*);
2680  };
2681 
2683  public:
2684  String* get_tag();
2685  void set_tag(const String&);
2686  };
2687 
2689  public:
2690  String* get_newURL();
2691  void set_newURL(const String&);
2692  String* get_oldURL();
2693  void set_oldURL(const String&);
2694  };
2695 
2696  class HkdfParams: public Algorithm {
2697  public:
2698  String* get_hash();
2699  void set_hash(const String&);
2700  Int8Array* get_info();
2701  void set_info(Int8Array*);
2702  Int8Array* get_salt();
2703  void set_salt(Int8Array*);
2704  };
2705 
2706  class HmacImportParams: public Algorithm {
2707  public:
2708  String* get_hash();
2709  void set_hash(const String&);
2710  double get_length();
2711  void set_length(double);
2712  };
2713 
2715  public:
2716  KeyAlgorithm* get_hash();
2717  void set_hash(KeyAlgorithm*);
2718  double get_length();
2719  void set_length(double);
2720  };
2721 
2722  class HmacKeyGenParams: public Algorithm {
2723  public:
2724  String* get_hash();
2725  void set_hash(const String&);
2726  double get_length();
2727  void set_length(double);
2728  };
2729 
2731  public:
2732  bool get_multiEntry();
2733  void set_multiEntry(bool);
2734  bool get_unique();
2735  void set_unique(bool);
2736  };
2737 
2739  public:
2740  bool get_autoIncrement();
2741  void set_autoIncrement(bool);
2742  String* get_keyPath();
2743  void set_keyPath(const String&);
2744  };
2745 
2747  public:
2748  Array* get_feedback();
2749  void set_feedback(Array*);
2750  Array* get_feedforward();
2751  void set_feedforward(Array*);
2752  };
2753 
2755  public:
2756  DOMRectInit* get_boundingClientRect();
2757  void set_boundingClientRect(DOMRectInit*);
2758  DOMRectInit* get_intersectionRect();
2759  void set_intersectionRect(DOMRectInit*);
2760  bool get_isIntersecting();
2761  void set_isIntersecting(bool);
2762  DOMRectInit* get_rootBounds();
2763  void set_rootBounds(DOMRectInit*);
2764  Element* get_target();
2765  void set_target(Element*);
2766  double get_time();
2767  void set_time(double);
2768  };
2769 
2771  public:
2772  Element* get_root();
2773  void set_root(Element*);
2774  String* get_rootMargin();
2775  void set_rootMargin(const String&);
2776  double get_threshold();
2777  void set_threshold(double);
2778  };
2779 
2780  class JsonWebKey: public Object{
2781  public:
2782  String* get_alg();
2783  void set_alg(const String&);
2784  String* get_crv();
2785  void set_crv(const String&);
2786  String* get_d();
2787  void set_d(const String&);
2788  String* get_dp();
2789  void set_dp(const String&);
2790  String* get_dq();
2791  void set_dq(const String&);
2792  String* get_e();
2793  void set_e(const String&);
2794  bool get_ext();
2795  void set_ext(bool);
2796  String* get_k();
2797  void set_k(const String&);
2798  Array* get_key_ops();
2799  void set_key_ops(Array*);
2800  String* get_kty();
2801  void set_kty(const String&);
2802  String* get_n();
2803  void set_n(const String&);
2804  Array* get_oth();
2805  void set_oth(Array*);
2806  String* get_p();
2807  void set_p(const String&);
2808  String* get_q();
2809  void set_q(const String&);
2810  String* get_qi();
2811  void set_qi(const String&);
2812  String* get_use();
2813  void set_use(const String&);
2814  String* get_x();
2815  void set_x(const String&);
2816  String* get_y();
2817  void set_y(const String&);
2818  };
2819 
2821  public:
2822  String* get_code();
2823  void set_code(const String&);
2824  String* get_key();
2825  void set_key(const String&);
2826  double get_location();
2827  void set_location(double);
2828  bool get_repeat();
2829  void set_repeat(bool);
2830  };
2831 
2832  class MSAccountInfo: public Object{
2833  public:
2834  String* get_accountImageUri();
2835  void set_accountImageUri(const String&);
2836  String* get_accountName();
2837  void set_accountName(const String&);
2838  String* get_rpDisplayName();
2839  void set_rpDisplayName(const String&);
2840  String* get_userDisplayName();
2841  void set_userDisplayName(const String&);
2842  String* get_userId();
2843  void set_userId(const String&);
2844  };
2845 
2846  class RTCStats: public Object{
2847  public:
2848  String* get_id();
2849  void set_id(const String&);
2850  String* get_msType();
2851  void set_msType(const String&);
2852  double get_timestamp();
2853  void set_timestamp(double);
2854  String* get_type();
2855  void set_type(const String&);
2856  };
2857 
2859  public:
2860  double get_networkBandwidthLowEventRatio();
2861  void set_networkBandwidthLowEventRatio(double);
2862  double get_networkReceiveQualityEventRatio();
2863  void set_networkReceiveQualityEventRatio(double);
2864  };
2865 
2867  public:
2868  double get_cpuInsufficientEventRatio();
2869  void set_cpuInsufficientEventRatio(double);
2870  double get_deviceCaptureNotFunctioningEventRatio();
2871  void set_deviceCaptureNotFunctioningEventRatio(double);
2872  double get_deviceClippingEventRatio();
2873  void set_deviceClippingEventRatio(double);
2874  double get_deviceEchoEventRatio();
2875  void set_deviceEchoEventRatio(double);
2876  double get_deviceGlitchesEventRatio();
2877  void set_deviceGlitchesEventRatio(double);
2878  double get_deviceHalfDuplexAECEventRatio();
2879  void set_deviceHalfDuplexAECEventRatio(double);
2880  double get_deviceHowlingEventCount();
2881  void set_deviceHowlingEventCount(double);
2882  double get_deviceLowSNREventRatio();
2883  void set_deviceLowSNREventRatio(double);
2884  double get_deviceLowSpeechLevelEventRatio();
2885  void set_deviceLowSpeechLevelEventRatio(double);
2886  double get_deviceMultipleEndpointsEventCount();
2887  void set_deviceMultipleEndpointsEventCount(double);
2888  double get_deviceNearEndToEchoRatioEventRatio();
2889  void set_deviceNearEndToEchoRatioEventRatio(double);
2890  double get_deviceRenderMuteEventRatio();
2891  void set_deviceRenderMuteEventRatio(double);
2892  double get_deviceRenderNotFunctioningEventRatio();
2893  void set_deviceRenderNotFunctioningEventRatio(double);
2894  double get_deviceRenderZeroVolumeEventRatio();
2895  void set_deviceRenderZeroVolumeEventRatio(double);
2896  double get_networkDelayEventRatio();
2897  void set_networkDelayEventRatio(double);
2898  double get_networkSendQualityEventRatio();
2899  void set_networkSendQualityEventRatio(double);
2900  };
2901 
2902  class MSPayloadBase: public RTCStats {
2903  public:
2904  String* get_payloadDescription();
2905  void set_payloadDescription(const String&);
2906  };
2907 
2909  public:
2910  double get_burstLossLength1();
2911  void set_burstLossLength1(double);
2912  double get_burstLossLength2();
2913  void set_burstLossLength2(double);
2914  double get_burstLossLength3();
2915  void set_burstLossLength3(double);
2916  double get_burstLossLength4();
2917  void set_burstLossLength4(double);
2918  double get_burstLossLength5();
2919  void set_burstLossLength5(double);
2920  double get_burstLossLength6();
2921  void set_burstLossLength6(double);
2922  double get_burstLossLength7();
2923  void set_burstLossLength7(double);
2924  double get_burstLossLength8OrHigher();
2925  void set_burstLossLength8OrHigher(double);
2926  double get_fecRecvDistance1();
2927  void set_fecRecvDistance1(double);
2928  double get_fecRecvDistance2();
2929  void set_fecRecvDistance2(double);
2930  double get_fecRecvDistance3();
2931  void set_fecRecvDistance3(double);
2932  double get_packetReorderDepthAvg();
2933  void set_packetReorderDepthAvg(double);
2934  double get_packetReorderDepthMax();
2935  void set_packetReorderDepthMax(double);
2936  double get_packetReorderRatio();
2937  void set_packetReorderRatio(double);
2938  double get_ratioCompressedSamplesAvg();
2939  void set_ratioCompressedSamplesAvg(double);
2940  double get_ratioConcealedSamplesAvg();
2941  void set_ratioConcealedSamplesAvg(double);
2942  double get_ratioStretchedSamplesAvg();
2943  void set_ratioStretchedSamplesAvg(double);
2944  double get_samplingRate();
2945  void set_samplingRate(double);
2946  MSAudioRecvSignal* get_signal();
2947  void set_signal(MSAudioRecvSignal*);
2948  };
2949 
2950  class MSAudioRecvSignal: public Object{
2951  public:
2952  double get_initialSignalLevelRMS();
2953  void set_initialSignalLevelRMS(double);
2954  double get_recvNoiseLevelCh1();
2955  void set_recvNoiseLevelCh1(double);
2956  double get_recvSignalLevelCh1();
2957  void set_recvSignalLevelCh1(double);
2958  double get_renderLoopbackSignalLevel();
2959  void set_renderLoopbackSignalLevel(double);
2960  double get_renderNoiseLevel();
2961  void set_renderNoiseLevel(double);
2962  double get_renderSignalLevel();
2963  void set_renderSignalLevel(double);
2964  };
2965 
2967  public:
2968  bool get_audioFECUsed();
2969  void set_audioFECUsed(bool);
2970  double get_samplingRate();
2971  void set_samplingRate(double);
2972  double get_sendMutePercent();
2973  void set_sendMutePercent(double);
2974  MSAudioSendSignal* get_signal();
2975  void set_signal(MSAudioSendSignal*);
2976  };
2977 
2978  class MSAudioSendSignal: public Object{
2979  public:
2980  double get_noiseLevel();
2981  void set_noiseLevel(double);
2982  double get_sendNoiseLevelCh1();
2983  void set_sendNoiseLevelCh1(double);
2984  double get_sendSignalLevelCh1();
2985  void set_sendSignalLevelCh1(double);
2986  };
2987 
2988  class MSConnectivity: public Object{
2989  public:
2990  String* get_iceType();
2991  void set_iceType(const String&);
2992  MSIceWarningFlags* get_iceWarningFlags();
2993  void set_iceWarningFlags(MSIceWarningFlags*);
2994  MSRelayAddress* get_relayAddress();
2995  void set_relayAddress(MSRelayAddress*);
2996  };
2997 
2999  public:
3000  Array* get_accept();
3001  void set_accept(Array*);
3002  };
3003 
3005  public:
3006  String* get_type();
3007  void set_type(const String&);
3008  };
3009 
3010  class MSCredentialSpec: public Object{
3011  public:
3012  String* get_id();
3013  void set_id(const String&);
3014  String* get_type();
3015  void set_type(const String&);
3016  };
3017 
3018  class MSDCCEventInit: public EventInit {
3019  public:
3020  double get_maxFr();
3021  void set_maxFr(double);
3022  double get_maxFs();
3023  void set_maxFs(double);
3024  };
3025 
3026  class MSDSHEventInit: public EventInit {
3027  public:
3028  Array* get_sources();
3029  void set_sources(Array*);
3030  double get_timestamp();
3031  void set_timestamp(double);
3032  };
3033 
3034  class MSDelay: public Object{
3035  public:
3036  double get_roundTrip();
3037  void set_roundTrip(double);
3038  double get_roundTripMax();
3039  void set_roundTripMax(double);
3040  };
3041 
3042  class MSDescription: public RTCStats {
3043  public:
3044  MSConnectivity* get_connectivity();
3045  void set_connectivity(MSConnectivity*);
3046  String* get_deviceDevName();
3047  void set_deviceDevName(const String&);
3048  MSIPAddressInfo* get_localAddr();
3049  void set_localAddr(MSIPAddressInfo*);
3050  MSNetworkConnectivityInfo* get_networkconnectivity();
3051  void set_networkconnectivity(MSNetworkConnectivityInfo*);
3052  MSIPAddressInfo* get_reflexiveLocalIPAddr();
3053  void set_reflexiveLocalIPAddr(MSIPAddressInfo*);
3054  MSIPAddressInfo* get_remoteAddr();
3055  void set_remoteAddr(MSIPAddressInfo*);
3056  String* get_transport();
3057  void set_transport(const String&);
3058  };
3059 
3061  public:
3062  String* get_algorithm();
3063  void set_algorithm(const String&);
3064  Array* get_authenticators();
3065  void set_authenticators(Array*);
3066  };
3067 
3068  class MSIPAddressInfo: public Object{
3069  public:
3070  String* get_ipAddr();
3071  void set_ipAddr(const String&);
3072  String* get_manufacturerMacAddrMask();
3073  void set_manufacturerMacAddrMask(const String&);
3074  double get_port();
3075  void set_port(double);
3076  };
3077 
3078  class MSIceWarningFlags: public Object{
3079  public:
3080  bool get_allocationMessageIntegrityFailed();
3081  void set_allocationMessageIntegrityFailed(bool);
3082  bool get_alternateServerReceived();
3083  void set_alternateServerReceived(bool);
3084  bool get_connCheckMessageIntegrityFailed();
3085  void set_connCheckMessageIntegrityFailed(bool);
3086  bool get_connCheckOtherError();
3087  void set_connCheckOtherError(bool);
3088  bool get_fipsAllocationFailure();
3089  void set_fipsAllocationFailure(bool);
3090  bool get_multipleRelayServersAttempted();
3091  void set_multipleRelayServersAttempted(bool);
3092  bool get_noRelayServersConfigured();
3093  void set_noRelayServersConfigured(bool);
3094  bool get_portRangeExhausted();
3095  void set_portRangeExhausted(bool);
3096  bool get_pseudoTLSFailure();
3097  void set_pseudoTLSFailure(bool);
3098  bool get_tcpNatConnectivityFailed();
3099  void set_tcpNatConnectivityFailed(bool);
3100  bool get_tcpRelayConnectivityFailed();
3101  void set_tcpRelayConnectivityFailed(bool);
3102  bool get_turnAuthUnknownUsernameError();
3103  void set_turnAuthUnknownUsernameError(bool);
3104  bool get_turnTcpAllocateFailed();
3105  void set_turnTcpAllocateFailed(bool);
3106  bool get_turnTcpSendFailed();
3107  void set_turnTcpSendFailed(bool);
3108  bool get_turnTcpTimedOut();
3109  void set_turnTcpTimedOut(bool);
3110  bool get_turnTurnTcpConnectivityFailed();
3111  void set_turnTurnTcpConnectivityFailed(bool);
3112  bool get_turnUdpAllocateFailed();
3113  void set_turnUdpAllocateFailed(bool);
3114  bool get_turnUdpSendFailed();
3115  void set_turnUdpSendFailed(bool);
3116  bool get_udpLocalConnectivityFailed();
3117  void set_udpLocalConnectivityFailed(bool);
3118  bool get_udpNatConnectivityFailed();
3119  void set_udpNatConnectivityFailed(bool);
3120  bool get_udpRelayConnectivityFailed();
3121  void set_udpRelayConnectivityFailed(bool);
3122  bool get_useCandidateChecksFailed();
3123  void set_useCandidateChecksFailed(bool);
3124  };
3125 
3126  class MSJitter: public Object{
3127  public:
3128  double get_interArrival();
3129  void set_interArrival(double);
3130  double get_interArrivalMax();
3131  void set_interArrivalMax(double);
3132  double get_interArrivalSD();
3133  void set_interArrivalSD(double);
3134  };
3135 
3136  class MSNetwork: public RTCStats {
3137  public:
3138  MSDelay* get_delay();
3139  void set_delay(MSDelay*);
3140  MSJitter* get_jitter();
3141  void set_jitter(MSJitter*);
3142  MSPacketLoss* get_packetLoss();
3143  void set_packetLoss(MSPacketLoss*);
3144  MSUtilization* get_utilization();
3145  void set_utilization(MSUtilization*);
3146  };
3147 
3149  public:
3150  double get_linkspeed();
3151  void set_linkspeed(double);
3152  String* get_networkConnectionDetails();
3153  void set_networkConnectionDetails(const String&);
3154  bool get_vpn();
3155  void set_vpn(bool);
3156  };
3157 
3159  public:
3160  bool get_interfaceTypeEthernet();
3161  void set_interfaceTypeEthernet(bool);
3162  bool get_interfaceTypePPP();
3163  void set_interfaceTypePPP(bool);
3164  bool get_interfaceTypeTunnel();
3165  void set_interfaceTypeTunnel(bool);
3166  bool get_interfaceTypeWWAN();
3167  void set_interfaceTypeWWAN(bool);
3168  bool get_interfaceTypeWireless();
3169  void set_interfaceTypeWireless(bool);
3170  };
3171 
3173  public:
3174  double get_appliedBandwidthLimit();
3175  void set_appliedBandwidthLimit(double);
3176  };
3177 
3178  class MSPacketLoss: public Object{
3179  public:
3180  double get_lossRate();
3181  void set_lossRate(double);
3182  double get_lossRateMax();
3183  void set_lossRateMax(double);
3184  };
3185 
3186  class MSPortRange: public Object{
3187  public:
3188  double get_max();
3189  void set_max(double);
3190  double get_min();
3191  void set_min(double);
3192  };
3193 
3194  class MSRelayAddress: public Object{
3195  public:
3196  double get_port();
3197  void set_port(double);
3198  String* get_relayAddress();
3199  void set_relayAddress(const String&);
3200  };
3201 
3203  public:
3204  String* get_userPrompt();
3205  void set_userPrompt(const String&);
3206  };
3207 
3209  public:
3210  double get_allocationTimeInMs();
3211  void set_allocationTimeInMs(double);
3212  String* get_baseAddress();
3213  void set_baseAddress(const String&);
3214  MSNetworkInterfaceType* get_baseInterface();
3215  void set_baseInterface(MSNetworkInterfaceType*);
3216  String* get_iceRole();
3217  void set_iceRole(const String&);
3218  MSIceWarningFlags* get_iceWarningFlags();
3219  void set_iceWarningFlags(MSIceWarningFlags*);
3220  MSNetworkInterfaceType* get_interfaces();
3221  void set_interfaces(MSNetworkInterfaceType*);
3222  String* get_localAddrType();
3223  void set_localAddrType(const String&);
3224  String* get_localAddress();
3225  void set_localAddress(const String&);
3226  MSNetworkInterfaceType* get_localInterface();
3227  void set_localInterface(MSNetworkInterfaceType*);
3228  String* get_localMR();
3229  void set_localMR(const String&);
3230  double get_localMRTCPPort();
3231  void set_localMRTCPPort(double);
3232  String* get_localSite();
3233  void set_localSite(const String&);
3234  String* get_msRtcEngineVersion();
3235  void set_msRtcEngineVersion(const String&);
3236  String* get_networkName();
3237  void set_networkName(const String&);
3238  double get_numConsentReqReceived();
3239  void set_numConsentReqReceived(double);
3240  double get_numConsentReqSent();
3241  void set_numConsentReqSent(double);
3242  double get_numConsentRespReceived();
3243  void set_numConsentRespReceived(double);
3244  double get_numConsentRespSent();
3245  void set_numConsentRespSent(double);
3246  double get_portRangeMax();
3247  void set_portRangeMax(double);
3248  double get_portRangeMin();
3249  void set_portRangeMin(double);
3250  String* get_protocol();
3251  void set_protocol(const String&);
3252  String* get_remoteAddrType();
3253  void set_remoteAddrType(const String&);
3254  String* get_remoteAddress();
3255  void set_remoteAddress(const String&);
3256  String* get_remoteMR();
3257  void set_remoteMR(const String&);
3258  double get_remoteMRTCPPort();
3259  void set_remoteMRTCPPort(double);
3260  String* get_remoteSite();
3261  void set_remoteSite(const String&);
3262  bool get_rtpRtcpMux();
3263  void set_rtpRtcpMux(bool);
3264  double get_stunVer();
3265  void set_stunVer(double);
3266  };
3267 
3268  class MSUtilization: public Object{
3269  public:
3270  double get_bandwidthEstimation();
3271  void set_bandwidthEstimation(double);
3272  double get_bandwidthEstimationAvg();
3273  void set_bandwidthEstimationAvg(double);
3274  double get_bandwidthEstimationMax();
3275  void set_bandwidthEstimationMax(double);
3276  double get_bandwidthEstimationMin();
3277  void set_bandwidthEstimationMin(double);
3278  double get_bandwidthEstimationStdDev();
3279  void set_bandwidthEstimationStdDev(double);
3280  double get_packets();
3281  void set_packets(double);
3282  };
3283 
3285  public:
3286  double get_durationSeconds();
3287  void set_durationSeconds(double);
3288  String* get_resolution();
3289  void set_resolution(const String&);
3290  double get_videoBitRateAvg();
3291  void set_videoBitRateAvg(double);
3292  double get_videoBitRateMax();
3293  void set_videoBitRateMax(double);
3294  double get_videoFrameRateAvg();
3295  void set_videoFrameRateAvg(double);
3296  double get_videoPacketLossRate();
3297  void set_videoPacketLossRate(double);
3298  };
3299 
3301  public:
3302  double get_lowBitRateCallPercent();
3303  void set_lowBitRateCallPercent(double);
3304  double get_lowFrameRateCallPercent();
3305  void set_lowFrameRateCallPercent(double);
3306  double get_recvBitRateAverage();
3307  void set_recvBitRateAverage(double);
3308  double get_recvBitRateMaximum();
3309  void set_recvBitRateMaximum(double);
3310  String* get_recvCodecType();
3311  void set_recvCodecType(const String&);
3312  double get_recvFpsHarmonicAverage();
3313  void set_recvFpsHarmonicAverage(double);
3314  double get_recvFrameRateAverage();
3315  void set_recvFrameRateAverage(double);
3316  double get_recvNumResSwitches();
3317  void set_recvNumResSwitches(double);
3318  double get_recvReorderBufferMaxSuccessfullyOrderedExtent();
3319  void set_recvReorderBufferMaxSuccessfullyOrderedExtent(double);
3320  double get_recvReorderBufferMaxSuccessfullyOrderedLateTime();
3321  void set_recvReorderBufferMaxSuccessfullyOrderedLateTime(double);
3322  double get_recvReorderBufferPacketsDroppedDueToBufferExhaustion();
3323  void set_recvReorderBufferPacketsDroppedDueToBufferExhaustion(double);
3324  double get_recvReorderBufferPacketsDroppedDueToTimeout();
3325  void set_recvReorderBufferPacketsDroppedDueToTimeout(double);
3326  double get_recvReorderBufferReorderedPackets();
3327  void set_recvReorderBufferReorderedPackets(double);
3328  double get_recvResolutionHeight();
3329  void set_recvResolutionHeight(double);
3330  double get_recvResolutionWidth();
3331  void set_recvResolutionWidth(double);
3332  double get_recvVideoStreamsMax();
3333  void set_recvVideoStreamsMax(double);
3334  double get_recvVideoStreamsMin();
3335  void set_recvVideoStreamsMin(double);
3336  double get_recvVideoStreamsMode();
3337  void set_recvVideoStreamsMode(double);
3338  double get_reorderBufferTotalPackets();
3339  void set_reorderBufferTotalPackets(double);
3340  double get_videoFrameLossRate();
3341  void set_videoFrameLossRate(double);
3342  double get_videoPostFECPLR();
3343  void set_videoPostFECPLR(double);
3344  MSVideoResolutionDistribution* get_videoResolutions();
3345  void set_videoResolutions(MSVideoResolutionDistribution*);
3346  };
3347 
3349  public:
3350  double get_cifQuality();
3351  void set_cifQuality(double);
3352  double get_h1080Quality();
3353  void set_h1080Quality(double);
3354  double get_h1440Quality();
3355  void set_h1440Quality(double);
3356  double get_h2160Quality();
3357  void set_h2160Quality(double);
3358  double get_h720Quality();
3359  void set_h720Quality(double);
3360  double get_vgaQuality();
3361  void set_vgaQuality(double);
3362  };
3363 
3365  public:
3366  double get_sendBitRateAverage();
3367  void set_sendBitRateAverage(double);
3368  double get_sendBitRateMaximum();
3369  void set_sendBitRateMaximum(double);
3370  double get_sendFrameRateAverage();
3371  void set_sendFrameRateAverage(double);
3372  double get_sendResolutionHeight();
3373  void set_sendResolutionHeight(double);
3374  double get_sendResolutionWidth();
3375  void set_sendResolutionWidth(double);
3376  double get_sendVideoStreamsMax();
3377  void set_sendVideoStreamsMax(double);
3378  };
3379 
3381  public:
3382  HTMLMediaElement* get_mediaElement();
3383  void set_mediaElement(HTMLMediaElement*);
3384  };
3385 
3387  public:
3388  ArrayBuffer* get_initData();
3389  void set_initData(ArrayBuffer*);
3390  String* get_initDataType();
3391  void set_initDataType(const String&);
3392  };
3393 
3395  public:
3396  ArrayBuffer* get_message();
3397  void set_message(ArrayBuffer*);
3398  String* get_messageType();
3399  void set_messageType(const String&);
3400  };
3401 
3403  public:
3404  Array* get_audioCapabilities();
3405  void set_audioCapabilities(Array*);
3406  String* get_distinctiveIdentifier();
3407  void set_distinctiveIdentifier(const String&);
3408  Array* get_initDataTypes();
3409  void set_initDataTypes(Array*);
3410  String* get_persistentState();
3411  void set_persistentState(const String&);
3412  Array* get_videoCapabilities();
3413  void set_videoCapabilities(Array*);
3414  };
3415 
3417  public:
3418  String* get_contentType();
3419  void set_contentType(const String&);
3420  String* get_robustness();
3421  void set_robustness(const String&);
3422  };
3423 
3425  public:
3426  bool get_audio();
3427  void set_audio(bool);
3428  bool get_video();
3429  void set_video(bool);
3430  };
3431 
3433  public:
3434  MediaStreamError* get_error();
3435  void set_error(MediaStreamError*);
3436  };
3437 
3439  public:
3440  MediaStream* get_stream();
3441  void set_stream(MediaStream*);
3442  };
3443 
3445  public:
3446  MediaStreamTrack* get_track();
3447  void set_track(MediaStreamTrack*);
3448  };
3449 
3451  public:
3452  double get_aspectRatio();
3453  void set_aspectRatio(double);
3454  String* get_deviceId();
3455  void set_deviceId(const String&);
3456  Array* get_echoCancellation();
3457  void set_echoCancellation(Array*);
3458  String* get_facingMode();
3459  void set_facingMode(const String&);
3460  double get_frameRate();
3461  void set_frameRate(double);
3462  String* get_groupId();
3463  void set_groupId(const String&);
3464  double get_height();
3465  void set_height(double);
3466  double get_sampleRate();
3467  void set_sampleRate(double);
3468  double get_sampleSize();
3469  void set_sampleSize(double);
3470  double get_volume();
3471  void set_volume(double);
3472  double get_width();
3473  void set_width(double);
3474  };
3475 
3477  public:
3478  double get_aspectRatio();
3479  void set_aspectRatio(double);
3480  double get_channelCount();
3481  void set_channelCount(double);
3482  String* get_deviceId();
3483  void set_deviceId(const String&);
3484  String* get_displaySurface();
3485  void set_displaySurface(const String&);
3486  bool get_echoCancellation();
3487  void set_echoCancellation(bool);
3488  String* get_facingMode();
3489  void set_facingMode(const String&);
3490  double get_frameRate();
3491  void set_frameRate(double);
3492  String* get_groupId();
3493  void set_groupId(const String&);
3494  double get_height();
3495  void set_height(double);
3496  double get_latency();
3497  void set_latency(double);
3498  bool get_logicalSurface();
3499  void set_logicalSurface(bool);
3500  double get_sampleRate();
3501  void set_sampleRate(double);
3502  double get_sampleSize();
3503  void set_sampleSize(double);
3504  double get_volume();
3505  void set_volume(double);
3506  double get_width();
3507  void set_width(double);
3508  };
3509 
3511  public:
3512  Array* get_advanced();
3513  void set_advanced(Array*);
3514  };
3515 
3517  public:
3518  double get_aspectRatio();
3519  void set_aspectRatio(double);
3520  String* get_deviceId();
3521  void set_deviceId(const String&);
3522  bool get_echoCancellation();
3523  void set_echoCancellation(bool);
3524  String* get_facingMode();
3525  void set_facingMode(const String&);
3526  double get_frameRate();
3527  void set_frameRate(double);
3528  String* get_groupId();
3529  void set_groupId(const String&);
3530  double get_height();
3531  void set_height(double);
3532  double get_sampleRate();
3533  void set_sampleRate(double);
3534  double get_sampleSize();
3535  void set_sampleSize(double);
3536  double get_volume();
3537  void set_volume(double);
3538  double get_width();
3539  void set_width(double);
3540  };
3541 
3543  public:
3544  bool get_aspectRatio();
3545  void set_aspectRatio(bool);
3546  bool get_deviceId();
3547  void set_deviceId(bool);
3548  bool get_echoCancellation();
3549  void set_echoCancellation(bool);
3550  bool get_facingMode();
3551  void set_facingMode(bool);
3552  bool get_frameRate();
3553  void set_frameRate(bool);
3554  bool get_groupId();
3555  void set_groupId(bool);
3556  bool get_height();
3557  void set_height(bool);
3558  bool get_sampleRate();
3559  void set_sampleRate(bool);
3560  bool get_sampleSize();
3561  void set_sampleSize(bool);
3562  bool get_volume();
3563  void set_volume(bool);
3564  bool get_width();
3565  void set_width(bool);
3566  };
3567 
3568  class MessageEventInit: public EventInit {
3569  public:
3570  String* get_channel();
3571  void set_channel(const String&);
3572  Object* get_data();
3573  void set_data(Object*);
3574  String* get_lastEventId();
3575  void set_lastEventId(const String&);
3576  String* get_origin();
3577  void set_origin(const String&);
3578  Array* get_ports();
3579  void set_ports(Array*);
3580  Window* get_source();
3581  void set_source(Window*);
3582  };
3583 
3585  public:
3586  double get_button();
3587  void set_button(double);
3588  double get_buttons();
3589  void set_buttons(double);
3590  double get_clientX();
3591  void set_clientX(double);
3592  double get_clientY();
3593  void set_clientY(double);
3594  EventTarget* get_relatedTarget();
3595  void set_relatedTarget(EventTarget*);
3596  double get_screenX();
3597  void set_screenX(double);
3598  double get_screenY();
3599  void set_screenY(double);
3600  };
3601 
3602  class MsZoomToOptions: public Object{
3603  public:
3604  String* get_animate();
3605  void set_animate(const String&);
3606  double get_contentX();
3607  void set_contentX(double);
3608  double get_contentY();
3609  void set_contentY(double);
3610  double get_scaleFactor();
3611  void set_scaleFactor(double);
3612  String* get_viewportX();
3613  void set_viewportX(const String&);
3614  String* get_viewportY();
3615  void set_viewportY(const String&);
3616  };
3617 
3619  public:
3620  Array* get_attributeFilter();
3621  void set_attributeFilter(Array*);
3622  bool get_attributeOldValue();
3623  void set_attributeOldValue(bool);
3624  bool get_attributes();
3625  void set_attributes(bool);
3626  bool get_characterData();
3627  void set_characterData(bool);
3628  bool get_characterDataOldValue();
3629  void set_characterDataOldValue(bool);
3630  bool get_childList();
3631  void set_childList(bool);
3632  bool get_subtree();
3633  void set_subtree(bool);
3634  };
3635 
3637  public:
3638  String* get_action();
3639  void set_action(const String&);
3640  Notification* get_notification();
3641  void set_notification(Notification*);
3642  };
3643 
3645  public:
3646  String* get_body();
3647  void set_body(const String&);
3648  Object* get_data();
3649  void set_data(Object*);
3650  String* get_dir();
3651  void set_dir(const String&);
3652  String* get_icon();
3653  void set_icon(const String&);
3654  String* get_lang();
3655  void set_lang(const String&);
3656  String* get_tag();
3657  void set_tag(const String&);
3658  };
3659 
3660  class ObjectURLOptions: public Object{
3661  public:
3662  bool get_oneTimeOnly();
3663  void set_oneTimeOnly(bool);
3664  };
3665 
3667  public:
3668  AudioBuffer* get_renderedBuffer();
3669  void set_renderedBuffer(AudioBuffer*);
3670  };
3671 
3673  public:
3674  double get_detune();
3675  void set_detune(double);
3676  double get_frequency();
3677  void set_frequency(double);
3678  PeriodicWave* get_periodicWave();
3679  void set_periodicWave(PeriodicWave*);
3680  String* get_type();
3681  void set_type(const String&);
3682  };
3683 
3685  public:
3686  double get_coneInnerAngle();
3687  void set_coneInnerAngle(double);
3688  double get_coneOuterAngle();
3689  void set_coneOuterAngle(double);
3690  double get_coneOuterGain();
3691  void set_coneOuterGain(double);
3692  String* get_distanceModel();
3693  void set_distanceModel(const String&);
3694  double get_maxDistance();
3695  void set_maxDistance(double);
3696  double get_orientationX();
3697  void set_orientationX(double);
3698  double get_orientationY();
3699  void set_orientationY(double);
3700  double get_orientationZ();
3701  void set_orientationZ(double);
3702  String* get_panningModel();
3703  void set_panningModel(const String&);
3704  double get_positionX();
3705  void set_positionX(double);
3706  double get_positionY();
3707  void set_positionY(double);
3708  double get_positionZ();
3709  void set_positionZ(double);
3710  double get_refDistance();
3711  void set_refDistance(double);
3712  double get_rolloffFactor();
3713  void set_rolloffFactor(double);
3714  };
3715 
3717  public:
3718  String* get_currency();
3719  void set_currency(const String&);
3720  String* get_currencySystem();
3721  void set_currencySystem(const String&);
3722  String* get_value();
3723  void set_value(const String&);
3724  };
3725 
3727  public:
3728  Array* get_displayItems();
3729  void set_displayItems(Array*);
3730  Array* get_modifiers();
3731  void set_modifiers(Array*);
3732  Array* get_shippingOptions();
3733  void set_shippingOptions(Array*);
3734  };
3735 
3737  public:
3738  String* get_id();
3739  void set_id(const String&);
3740  PaymentItem* get_total();
3741  void set_total(PaymentItem*);
3742  };
3743 
3745  public:
3746  Array* get_additionalDisplayItems();
3747  void set_additionalDisplayItems(Array*);
3748  Object* get_data();
3749  void set_data(Object*);
3750  String* get_supportedMethods();
3751  void set_supportedMethods(const String&);
3752  PaymentItem* get_total();
3753  void set_total(PaymentItem*);
3754  };
3755 
3757  public:
3758  String* get_error();
3759  void set_error(const String&);
3760  PaymentItem* get_total();
3761  void set_total(PaymentItem*);
3762  };
3763 
3764  class PaymentItem: public Object{
3765  public:
3766  PaymentCurrencyAmount* get_amount();
3767  void set_amount(PaymentCurrencyAmount*);
3768  String* get_label();
3769  void set_label(const String&);
3770  bool get_pending();
3771  void set_pending(bool);
3772  };
3773 
3774  class PaymentMethodData: public Object{
3775  public:
3776  Object* get_data();
3777  void set_data(Object*);
3778  String* get_supportedMethods();
3779  void set_supportedMethods(const String&);
3780  };
3781 
3782  class PaymentOptions: public Object{
3783  public:
3784  bool get_requestPayerEmail();
3785  void set_requestPayerEmail(bool);
3786  bool get_requestPayerName();
3787  void set_requestPayerName(bool);
3788  bool get_requestPayerPhone();
3789  void set_requestPayerPhone(bool);
3790  bool get_requestShipping();
3791  void set_requestShipping(bool);
3792  String* get_shippingType();
3793  void set_shippingType(const String&);
3794  };
3795 
3797  public:
3798  };
3799 
3801  public:
3802  PaymentCurrencyAmount* get_amount();
3803  void set_amount(PaymentCurrencyAmount*);
3804  String* get_id();
3805  void set_id(const String&);
3806  String* get_label();
3807  void set_label(const String&);
3808  bool get_selected();
3809  void set_selected(bool);
3810  };
3811 
3812  class Pbkdf2Params: public Algorithm {
3813  public:
3814  String* get_hash();
3815  void set_hash(const String&);
3816  double get_iterations();
3817  void set_iterations(double);
3818  Int8Array* get_salt();
3819  void set_salt(Int8Array*);
3820  };
3821 
3823  public:
3824  bool get_disableNormalization();
3825  void set_disableNormalization(bool);
3826  };
3827 
3829  public:
3830  Array* get_imag();
3831  void set_imag(Array*);
3832  Array* get_real();
3833  void set_real(Array*);
3834  };
3835 
3837  public:
3838  double get_height();
3839  void set_height(double);
3840  bool get_isPrimary();
3841  void set_isPrimary(bool);
3842  double get_pointerId();
3843  void set_pointerId(double);
3844  String* get_pointerType();
3845  void set_pointerType(const String&);
3846  double get_pressure();
3847  void set_pressure(double);
3848  double get_tiltX();
3849  void set_tiltX(double);
3850  double get_tiltY();
3851  void set_tiltY(double);
3852  double get_width();
3853  void set_width(double);
3854  };
3855 
3857  public:
3858  Object* get_state();
3859  void set_state(Object*);
3860  };
3861 
3862  class PositionOptions: public Object{
3863  public:
3864  bool get_enableHighAccuracy();
3865  void set_enableHighAccuracy(bool);
3866  double get_maximumAge();
3867  void set_maximumAge(double);
3868  double get_timeout();
3869  void set_timeout(double);
3870  };
3871 
3873  public:
3874  bool get_lengthComputable();
3875  void set_lengthComputable(bool);
3876  double get_loaded();
3877  void set_loaded(double);
3878  double get_total();
3879  void set_total(double);
3880  };
3881 
3883  public:
3884  Int8Array* get_data();
3885  void set_data(Int8Array*);
3886  };
3887 
3889  public:
3890  PushSubscription* get_newSubscription();
3891  void set_newSubscription(PushSubscription*);
3892  PushSubscription* get_oldSubscription();
3893  void set_oldSubscription(PushSubscription*);
3894  };
3895 
3897  public:
3898  Int8Array* get_applicationServerKey();
3899  void set_applicationServerKey(Int8Array*);
3900  bool get_userVisibleOnly();
3901  void set_userVisibleOnly(bool);
3902  };
3903 
3904  class QueuingStrategy: public Object{
3905  public:
3906  double get_highWaterMark();
3907  void set_highWaterMark(double);
3908  EventListener* get_size();
3909  void set_size(EventListener*);
3910  };
3911 
3912  class RTCConfiguration: public Object{
3913  public:
3914  String* get_bundlePolicy();
3915  void set_bundlePolicy(const String&);
3916  Array* get_iceServers();
3917  void set_iceServers(Array*);
3918  String* get_iceTransportPolicy();
3919  void set_iceTransportPolicy(const String&);
3920  String* get_peerIdentity();
3921  void set_peerIdentity(const String&);
3922  };
3923 
3925  public:
3926  String* get_tone();
3927  void set_tone(const String&);
3928  };
3929 
3931  public:
3932  String* get_algorithm();
3933  void set_algorithm(const String&);
3934  String* get_value();
3935  void set_value(const String&);
3936  };
3937 
3938  class RTCDtlsParameters: public Object{
3939  public:
3940  Array* get_fingerprints();
3941  void set_fingerprints(Array*);
3942  String* get_role();
3943  void set_role(const String&);
3944  };
3945 
3947  public:
3948  String* get_addressSourceUrl();
3949  void set_addressSourceUrl(const String&);
3950  String* get_candidateType();
3951  void set_candidateType(const String&);
3952  String* get_ipAddress();
3953  void set_ipAddress(const String&);
3954  double get_portNumber();
3955  void set_portNumber(double);
3956  double get_priority();
3957  void set_priority(double);
3958  String* get_transport();
3959  void set_transport(const String&);
3960  };
3961 
3963  public:
3964  };
3965 
3967  public:
3968  String* get_foundation();
3969  void set_foundation(const String&);
3970  String* get_ip();
3971  void set_ip(const String&);
3972  String* get_msMTurnSessionId();
3973  void set_msMTurnSessionId(const String&);
3974  double get_port();
3975  void set_port(double);
3976  double get_priority();
3977  void set_priority(double);
3978  String* get_protocol();
3979  void set_protocol(const String&);
3980  String* get_relatedAddress();
3981  void set_relatedAddress(const String&);
3982  double get_relatedPort();
3983  void set_relatedPort(double);
3984  String* get_tcpType();
3985  void set_tcpType(const String&);
3986  String* get_type();
3987  void set_type(const String&);
3988  };
3989 
3991  public:
3992  String* get_candidate();
3993  void set_candidate(const String&);
3994  double get_sdpMLineIndex();
3995  void set_sdpMLineIndex(double);
3996  String* get_sdpMid();
3997  void set_sdpMid(const String&);
3998  };
3999 
4001  public:
4002  RTCIceCandidateDictionary* get_local();
4003  void set_local(RTCIceCandidateDictionary*);
4004  RTCIceCandidateDictionary* get_remote();
4005  void set_remote(RTCIceCandidateDictionary*);
4006  };
4007 
4009  public:
4010  double get_availableIncomingBitrate();
4011  void set_availableIncomingBitrate(double);
4012  double get_availableOutgoingBitrate();
4013  void set_availableOutgoingBitrate(double);
4014  double get_bytesReceived();
4015  void set_bytesReceived(double);
4016  double get_bytesSent();
4017  void set_bytesSent(double);
4018  String* get_localCandidateId();
4019  void set_localCandidateId(const String&);
4020  bool get_nominated();
4021  void set_nominated(bool);
4022  double get_priority();
4023  void set_priority(double);
4024  bool get_readable();
4025  void set_readable(bool);
4026  String* get_remoteCandidateId();
4027  void set_remoteCandidateId(const String&);
4028  double get_roundTripTime();
4029  void set_roundTripTime(double);
4030  String* get_state();
4031  void set_state(const String&);
4032  String* get_transportId();
4033  void set_transportId(const String&);
4034  bool get_writable();
4035  void set_writable(bool);
4036  };
4037 
4039  public:
4040  String* get_gatherPolicy();
4041  void set_gatherPolicy(const String&);
4042  Array* get_iceservers();
4043  void set_iceservers(Array*);
4044  MSPortRange* get_portRange();
4045  void set_portRange(MSPortRange*);
4046  };
4047 
4048  class RTCIceParameters: public Object{
4049  public:
4050  bool get_iceLite();
4051  void set_iceLite(bool);
4052  String* get_password();
4053  void set_password(const String&);
4054  String* get_usernameFragment();
4055  void set_usernameFragment(const String&);
4056  };
4057 
4058  class RTCIceServer: public Object{
4059  public:
4060  String* get_credential();
4061  void set_credential(const String&);
4062  Object* get_urls();
4063  void set_urls(Object*);
4064  String* get_username();
4065  void set_username(const String&);
4066  };
4067 
4068  class RTCRTPStreamStats: public RTCStats {
4069  public:
4070  String* get_associateStatsId();
4071  void set_associateStatsId(const String&);
4072  String* get_codecId();
4073  void set_codecId(const String&);
4074  double get_firCount();
4075  void set_firCount(double);
4076  bool get_isRemote();
4077  void set_isRemote(bool);
4078  String* get_mediaTrackId();
4079  void set_mediaTrackId(const String&);
4080  String* get_mediaType();
4081  void set_mediaType(const String&);
4082  double get_nackCount();
4083  void set_nackCount(double);
4084  double get_pliCount();
4085  void set_pliCount(double);
4086  double get_sliCount();
4087  void set_sliCount(double);
4088  String* get_ssrc();
4089  void set_ssrc(const String&);
4090  String* get_transportId();
4091  void set_transportId(const String&);
4092  };
4093 
4095  public:
4096  double get_bytesReceived();
4097  void set_bytesReceived(double);
4098  double get_fractionLost();
4099  void set_fractionLost(double);
4100  double get_jitter();
4101  void set_jitter(double);
4102  double get_packetsLost();
4103  void set_packetsLost(double);
4104  double get_packetsReceived();
4105  void set_packetsReceived(double);
4106  };
4107 
4109  public:
4110  double get_audioLevel();
4111  void set_audioLevel(double);
4112  double get_echoReturnLoss();
4113  void set_echoReturnLoss(double);
4114  double get_echoReturnLossEnhancement();
4115  void set_echoReturnLossEnhancement(double);
4116  double get_frameHeight();
4117  void set_frameHeight(double);
4118  double get_frameWidth();
4119  void set_frameWidth(double);
4120  double get_framesCorrupted();
4121  void set_framesCorrupted(double);
4122  double get_framesDecoded();
4123  void set_framesDecoded(double);
4124  double get_framesDropped();
4125  void set_framesDropped(double);
4126  double get_framesPerSecond();
4127  void set_framesPerSecond(double);
4128  double get_framesReceived();
4129  void set_framesReceived(double);
4130  double get_framesSent();
4131  void set_framesSent(double);
4132  bool get_remoteSource();
4133  void set_remoteSource(bool);
4134  Array* get_ssrcIds();
4135  void set_ssrcIds(Array*);
4136  String* get_trackIdentifier();
4137  void set_trackIdentifier(const String&);
4138  };
4139 
4140  class RTCOfferOptions: public Object{
4141  public:
4142  bool get_iceRestart();
4143  void set_iceRestart(bool);
4144  double get_offerToReceiveAudio();
4145  void set_offerToReceiveAudio(double);
4146  double get_offerToReceiveVideo();
4147  void set_offerToReceiveVideo(double);
4148  bool get_voiceActivityDetection();
4149  void set_voiceActivityDetection(bool);
4150  };
4151 
4153  public:
4154  double get_bytesSent();
4155  void set_bytesSent(double);
4156  double get_packetsSent();
4157  void set_packetsSent(double);
4158  double get_roundTripTime();
4159  void set_roundTripTime(double);
4160  double get_targetBitrate();
4161  void set_targetBitrate(double);
4162  };
4163 
4165  public:
4166  RTCIceCandidate* get_candidate();
4167  void set_candidate(RTCIceCandidate*);
4168  };
4169 
4170  class RTCRtcpFeedback: public Object{
4171  public:
4172  String* get_parameter();
4173  void set_parameter(const String&);
4174  String* get_type();
4175  void set_type(const String&);
4176  };
4177 
4178  class RTCRtcpParameters: public Object{
4179  public:
4180  String* get_cname();
4181  void set_cname(const String&);
4182  bool get_mux();
4183  void set_mux(bool);
4184  bool get_reducedSize();
4185  void set_reducedSize(bool);
4186  double get_ssrc();
4187  void set_ssrc(double);
4188  };
4189 
4191  public:
4192  Array* get_codecs();
4193  void set_codecs(Array*);
4194  Array* get_fecMechanisms();
4195  void set_fecMechanisms(Array*);
4196  Array* get_headerExtensions();
4197  void set_headerExtensions(Array*);
4198  };
4199 
4201  public:
4202  double get_clockRate();
4203  void set_clockRate(double);
4204  String* get_kind();
4205  void set_kind(const String&);
4206  double get_maxSpatialLayers();
4207  void set_maxSpatialLayers(double);
4208  double get_maxTemporalLayers();
4209  void set_maxTemporalLayers(double);
4210  double get_maxptime();
4211  void set_maxptime(double);
4212  String* get_name();
4213  void set_name(const String&);
4214  double get_numChannels();
4215  void set_numChannels(double);
4216  Object* get_options();
4217  void set_options(Object*);
4218  Object* get_parameters();
4219  void set_parameters(Object*);
4220  double get_preferredPayloadType();
4221  void set_preferredPayloadType(double);
4222  double get_ptime();
4223  void set_ptime(double);
4224  Array* get_rtcpFeedback();
4225  void set_rtcpFeedback(Array*);
4226  bool get_svcMultiStreamSupport();
4227  void set_svcMultiStreamSupport(bool);
4228  };
4229 
4231  public:
4232  double get_clockRate();
4233  void set_clockRate(double);
4234  double get_maxptime();
4235  void set_maxptime(double);
4236  String* get_name();
4237  void set_name(const String&);
4238  double get_numChannels();
4239  void set_numChannels(double);
4240  Object* get_parameters();
4241  void set_parameters(Object*);
4242  double get_payloadType();
4243  void set_payloadType(double);
4244  double get_ptime();
4245  void set_ptime(double);
4246  Array* get_rtcpFeedback();
4247  void set_rtcpFeedback(Array*);
4248  };
4249 
4251  public:
4252  double get_audioLevel();
4253  void set_audioLevel(double);
4254  double get_csrc();
4255  void set_csrc(double);
4256  double get_timestamp();
4257  void set_timestamp(double);
4258  };
4259 
4261  public:
4262  bool get_active();
4263  void set_active(bool);
4264  double get_codecPayloadType();
4265  void set_codecPayloadType(double);
4266  Array* get_dependencyEncodingIds();
4267  void set_dependencyEncodingIds(Array*);
4268  String* get_encodingId();
4269  void set_encodingId(const String&);
4270  RTCRtpFecParameters* get_fec();
4271  void set_fec(RTCRtpFecParameters*);
4272  double get_framerateScale();
4273  void set_framerateScale(double);
4274  double get_maxBitrate();
4275  void set_maxBitrate(double);
4276  double get_maxFramerate();
4277  void set_maxFramerate(double);
4278  double get_minQuality();
4279  void set_minQuality(double);
4280  double get_priority();
4281  void set_priority(double);
4282  double get_resolutionScale();
4283  void set_resolutionScale(double);
4284  RTCRtpRtxParameters* get_rtx();
4285  void set_rtx(RTCRtpRtxParameters*);
4286  double get_ssrc();
4287  void set_ssrc(double);
4288  RTCSsrcRange* get_ssrcRange();
4289  void set_ssrcRange(RTCSsrcRange*);
4290  };
4291 
4293  public:
4294  String* get_mechanism();
4295  void set_mechanism(const String&);
4296  double get_ssrc();
4297  void set_ssrc(double);
4298  };
4299 
4301  public:
4302  String* get_kind();
4303  void set_kind(const String&);
4304  bool get_preferredEncrypt();
4305  void set_preferredEncrypt(bool);
4306  double get_preferredId();
4307  void set_preferredId(double);
4308  String* get_uri();
4309  void set_uri(const String&);
4310  };
4311 
4313  public:
4314  bool get_encrypt();
4315  void set_encrypt(bool);
4316  double get_id();
4317  void set_id(double);
4318  String* get_uri();
4319  void set_uri(const String&);
4320  };
4321 
4322  class RTCRtpParameters: public Object{
4323  public:
4324  Array* get_codecs();
4325  void set_codecs(Array*);
4326  String* get_degradationPreference();
4327  void set_degradationPreference(const String&);
4328  Array* get_encodings();
4329  void set_encodings(Array*);
4330  Array* get_headerExtensions();
4331  void set_headerExtensions(Array*);
4332  String* get_muxId();
4333  void set_muxId(const String&);
4334  RTCRtcpParameters* get_rtcp();
4335  void set_rtcp(RTCRtcpParameters*);
4336  };
4337 
4339  public:
4340  double get_ssrc();
4341  void set_ssrc(double);
4342  };
4343 
4344  class RTCRtpUnhandled: public Object{
4345  public:
4346  String* get_muxId();
4347  void set_muxId(const String&);
4348  double get_payloadType();
4349  void set_payloadType(double);
4350  double get_ssrc();
4351  void set_ssrc(double);
4352  };
4353 
4355  public:
4356  String* get_sdp();
4357  void set_sdp(const String&);
4358  String* get_type();
4359  void set_type(const String&);
4360  };
4361 
4362  class RTCSrtpKeyParam: public Object{
4363  public:
4364  String* get_keyMethod();
4365  void set_keyMethod(const String&);
4366  String* get_keySalt();
4367  void set_keySalt(const String&);
4368  String* get_lifetime();
4369  void set_lifetime(const String&);
4370  double get_mkiLength();
4371  void set_mkiLength(double);
4372  double get_mkiValue();
4373  void set_mkiValue(double);
4374  };
4375 
4377  public:
4378  String* get_cryptoSuite();
4379  void set_cryptoSuite(const String&);
4380  Array* get_keyParams();
4381  void set_keyParams(Array*);
4382  Array* get_sessionParams();
4383  void set_sessionParams(Array*);
4384  double get_tag();
4385  void set_tag(double);
4386  };
4387 
4388  class RTCSsrcRange: public Object{
4389  public:
4390  double get_max();
4391  void set_max(double);
4392  double get_min();
4393  void set_min(double);
4394  };
4395 
4396  class RTCStatsReport: public Object{
4397  public:
4398  };
4399 
4400  class RTCTransportStats: public RTCStats {
4401  public:
4402  bool get_activeConnection();
4403  void set_activeConnection(bool);
4404  double get_bytesReceived();
4405  void set_bytesReceived(double);
4406  double get_bytesSent();
4407  void set_bytesSent(double);
4408  String* get_localCertificateId();
4409  void set_localCertificateId(const String&);
4410  String* get_remoteCertificateId();
4411  void set_remoteCertificateId(const String&);
4412  String* get_rtcpTransportStatsId();
4413  void set_rtcpTransportStatsId(const String&);
4414  String* get_selectedCandidatePairId();
4415  void set_selectedCandidatePairId(const String&);
4416  };
4417 
4419  public:
4420  String* get_scope();
4421  void set_scope(const String&);
4422  };
4423 
4424  class RequestInit: public Object{
4425  public:
4426  Blob* get_body();
4427  void set_body(Blob*);
4428  String* get_cache();
4429  void set_cache(const String&);
4430  String* get_credentials();
4431  void set_credentials(const String&);
4432  Headers* get_headers();
4433  void set_headers(Headers*);
4434  String* get_integrity();
4435  void set_integrity(const String&);
4436  bool get_keepalive();
4437  void set_keepalive(bool);
4438  String* get_method();
4439  void set_method(const String&);
4440  String* get_mode();
4441  void set_mode(const String&);
4442  String* get_redirect();
4443  void set_redirect(const String&);
4444  String* get_referrer();
4445  void set_referrer(const String&);
4446  String* get_referrerPolicy();
4447  void set_referrerPolicy(const String&);
4448  AbortSignal* get_signal();
4449  void set_signal(AbortSignal*);
4450  Object* get_window();
4451  void set_window(Object*);
4452  };
4453 
4454  class ResponseInit: public Object{
4455  public:
4456  Headers* get_headers();
4457  void set_headers(Headers*);
4458  double get_status();
4459  void set_status(double);
4460  String* get_statusText();
4461  void set_statusText(const String&);
4462  };
4463 
4465  public:
4466  String* get_hash();
4467  void set_hash(const String&);
4468  };
4469 
4471  public:
4472  double get_modulusLength();
4473  void set_modulusLength(double);
4474  Uint8Array* get_publicExponent();
4475  void set_publicExponent(Uint8Array*);
4476  };
4477 
4479  public:
4480  KeyAlgorithm* get_hash();
4481  void set_hash(KeyAlgorithm*);
4482  };
4483 
4484  class RsaKeyGenParams: public Algorithm {
4485  public:
4486  double get_modulusLength();
4487  void set_modulusLength(double);
4488  Uint8Array* get_publicExponent();
4489  void set_publicExponent(Uint8Array*);
4490  };
4491 
4493  public:
4494  String* get_hash();
4495  void set_hash(const String&);
4496  };
4497 
4498  class RsaOaepParams: public Algorithm {
4499  public:
4500  Int8Array* get_label();
4501  void set_label(Int8Array*);
4502  };
4503 
4505  public:
4506  String* get_d();
4507  void set_d(const String&);
4508  String* get_r();
4509  void set_r(const String&);
4510  String* get_t();
4511  void set_t(const String&);
4512  };
4513 
4514  class RsaPssParams: public Algorithm {
4515  public:
4516  double get_saltLength();
4517  void set_saltLength(double);
4518  };
4519 
4521  public:
4522  Int8Array* get_id();
4523  void set_id(Int8Array*);
4524  Array* get_transports();
4525  void set_transports(Array*);
4526  String* get_type();
4527  void set_type(const String&);
4528  };
4529 
4531  public:
4532  Array* get_excludeList();
4533  void set_excludeList(Array*);
4534  WebAuthnExtensions* get_extensions();
4535  void set_extensions(WebAuthnExtensions*);
4536  String* get_rpId();
4537  void set_rpId(const String&);
4538  double get_timeoutSeconds();
4539  void set_timeoutSeconds(double);
4540  };
4541 
4543  public:
4544  String* get_algorithm();
4545  void set_algorithm(const String&);
4546  String* get_type();
4547  void set_type(const String&);
4548  };
4549 
4551  public:
4552  String* get_blockedURI();
4553  void set_blockedURI(const String&);
4554  double get_columnNumber();
4555  void set_columnNumber(double);
4556  String* get_documentURI();
4557  void set_documentURI(const String&);
4558  String* get_effectiveDirective();
4559  void set_effectiveDirective(const String&);
4560  double get_lineNumber();
4561  void set_lineNumber(double);
4562  String* get_originalPolicy();
4563  void set_originalPolicy(const String&);
4564  String* get_referrer();
4565  void set_referrer(const String&);
4566  String* get_sourceFile();
4567  void set_sourceFile(const String&);
4568  double get_statusCode();
4569  void set_statusCode(double);
4570  String* get_violatedDirective();
4571  void set_violatedDirective(const String&);
4572  };
4573 
4575  public:
4576  Object* get_data();
4577  void set_data(Object*);
4578  String* get_lastEventId();
4579  void set_lastEventId(const String&);
4580  String* get_origin();
4581  void set_origin(const String&);
4582  Array* get_ports();
4583  void set_ports(Array*);
4584  ServiceWorker* get_source();
4585  void set_source(ServiceWorker*);
4586  };
4587 
4589  public:
4590  double get_charIndex();
4591  void set_charIndex(double);
4592  double get_charLength();
4593  void set_charLength(double);
4594  double get_elapsedTime();
4595  void set_elapsedTime(double);
4596  String* get_name();
4597  void set_name(const String&);
4598  SpeechSynthesisUtterance* get_utterance();
4599  void set_utterance(SpeechSynthesisUtterance*);
4600  };
4601 
4603  public:
4604  double get_pan();
4605  void set_pan(double);
4606  };
4607 
4609  public:
4610  String* get_detailURI();
4611  void set_detailURI(const String&);
4612  String* get_explanationString();
4613  void set_explanationString(const String&);
4614  String* get_siteName();
4615  void set_siteName(const String&);
4616  };
4617 
4619  public:
4620  Array* get_arrayOfDomainStrings();
4621  void set_arrayOfDomainStrings(Array*);
4622  };
4623 
4625  public:
4626  bool get_lastChance();
4627  void set_lastChance(bool);
4628  String* get_tag();
4629  void set_tag(const String&);
4630  };
4631 
4632  class TextDecodeOptions: public Object{
4633  public:
4634  bool get_stream();
4635  void set_stream(bool);
4636  };
4637 
4639  public:
4640  bool get_fatal();
4641  void set_fatal(bool);
4642  bool get_ignoreBOM();
4643  void set_ignoreBOM(bool);
4644  };
4645 
4646  class TrackEventInit: public EventInit {
4647  public:
4648  VideoTrack* get_track();
4649  void set_track(VideoTrack*);
4650  };
4651 
4653  public:
4654  double get_elapsedTime();
4655  void set_elapsedTime(double);
4656  String* get_propertyName();
4657  void set_propertyName(const String&);
4658  };
4659 
4660  class UnderlyingSink: public Object{
4661  public:
4662  EventListener* get_abort();
4663  void set_abort(EventListener*);
4664  EventListener* get_close();
4665  void set_close(EventListener*);
4666  EventListener* get_start();
4667  void set_start(EventListener*);
4668  EventListener* get_write();
4669  void set_write(EventListener*);
4670  };
4671 
4673  public:
4674  VRDisplay* get_display();
4675  void set_display(VRDisplay*);
4676  String* get_reason();
4677  void set_reason(const String&);
4678  };
4679 
4680  class VRLayer: public Object{
4681  public:
4682  Array* get_leftBounds();
4683  void set_leftBounds(Array*);
4684  Array* get_rightBounds();
4685  void set_rightBounds(Array*);
4686  HTMLCanvasElement* get_source();
4687  void set_source(HTMLCanvasElement*);
4688  };
4689 
4690  class VRStageParameters: public Object{
4691  public:
4692  Float32Array* get_sittingToStandingTransform();
4693  void set_sittingToStandingTransform(Float32Array*);
4694  double get_sizeX();
4695  void set_sizeX(double);
4696  double get_sizeY();
4697  void set_sizeY(double);
4698  };
4699 
4701  public:
4702  Array* get_curve();
4703  void set_curve(Array*);
4704  String* get_oversample();
4705  void set_oversample(const String&);
4706  };
4707 
4709  public:
4710  };
4711 
4713  public:
4714  double get_deltaMode();
4715  void set_deltaMode(double);
4716  double get_deltaX();
4717  void set_deltaX(double);
4718  double get_deltaY();
4719  void set_deltaY(double);
4720  double get_deltaZ();
4721  void set_deltaZ(double);
4722  };
4723 
4724  class EventListener: public Object{
4725  public:
4726  };
4727 
4729  public:
4730  void drawArraysInstancedANGLE(double mode, double first, double count, double primcount);
4731  void drawElementsInstancedANGLE(double mode, double count, double type, double offset, double primcount);
4732  void vertexAttribDivisorANGLE(double index, double divisor);
4733  ANGLE_instanced_arrays* get_prototype();
4734  void set_prototype(ANGLE_instanced_arrays*);
4736  double get_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE();
4737  };
4738 
4739  class AbortController: public Object{
4740  public:
4741  AbortSignal* get_signal();
4742  void abort();
4743  AbortController* get_prototype();
4744  void set_prototype(AbortController*);
4745  AbortController();
4746  };
4747 
4749  public:
4750  ProgressEvent* get_abort();
4751  void set_abort(ProgressEvent*);
4752  };
4753 
4754  class EventTarget: public Object{
4755  public:
4756  void addEventListener(const String& type, EventListener* listener);
4757  void addEventListener(const String& type, EventListener* listener, bool options);
4758  void addEventListener(const String& type, EventListener* listener, AddEventListenerOptions* options);
4759  void addEventListener(const String& type, EventListenerObject* listener);
4760  void addEventListener(const String& type, EventListenerObject* listener, AddEventListenerOptions* options);
4761  bool dispatchEvent(Event* evt);
4762  void removeEventListener(const String& type);
4763  void removeEventListener(const String& type, EventListener* listener);
4764  void removeEventListener(const String& type, EventListener* listener, EventListenerOptions* options);
4765  void removeEventListener(const String& type, EventListener* listener, bool options);
4766  void removeEventListener(const String& type, EventListenerObject* listener);
4767  void removeEventListener(const String& type, EventListenerObject* listener, bool options);
4768  EventTarget* get_prototype();
4769  void set_prototype(EventTarget*);
4770  EventTarget();
4771  };
4772 
4773  class AbortSignal: public EventTarget {
4774  public:
4775  bool get_aborted();
4776  EventListener* get_onabort();
4777  void set_onabort(EventListener*);
4778  void addEventListener(const String& type, EventListener* listener);
4779  void addEventListener(const String& type, EventListener* listener, bool options);
4780  void addEventListener(const String& type, EventListener* listener, AddEventListenerOptions* options);
4781  void addEventListener(const String& type, EventListenerObject* listener);
4782  void addEventListener(const String& type, EventListenerObject* listener, AddEventListenerOptions* options);
4783  void removeEventListener(const String& type, EventListener* listener);
4784  void removeEventListener(const String& type, EventListener* listener, bool options);
4785  void removeEventListener(const String& type, EventListener* listener, EventListenerOptions* options);
4786  void removeEventListener(const String& type, EventListenerObject* listener);
4787  void removeEventListener(const String& type, EventListenerObject* listener, EventListenerOptions* options);
4788  AbortSignal* get_prototype();
4789  void set_prototype(AbortSignal*);
4790  AbortSignal();
4791  };
4792 
4794  public:
4795  ErrorEvent* get_error();
4796  void set_error(ErrorEvent*);
4797  };
4798 
4800  public:
4801  EventListener* get_onerror();
4802  void set_onerror(EventListener*);
4803  void addEventListener(const String& type, EventListener* listener);
4804  void addEventListener(const String& type, EventListener* listener, bool options);
4805  void addEventListener(const String& type, EventListener* listener, AddEventListenerOptions* options);
4806  void addEventListener(const String& type, EventListenerObject* listener);
4807  void addEventListener(const String& type, EventListenerObject* listener, AddEventListenerOptions* options);
4808  void removeEventListener(const String& type, EventListener* listener);
4809  void removeEventListener(const String& type, EventListener* listener, bool options);
4810  void removeEventListener(const String& type, EventListener* listener, EventListenerOptions* options);
4811  void removeEventListener(const String& type, EventListenerObject* listener);
4812  void removeEventListener(const String& type, EventListenerObject* listener, EventListenerOptions* options);
4813  };
4814 
4815  class AesCfbParams: public Algorithm {
4816  public:
4817  Int8Array* get_iv();
4818  void set_iv(Int8Array*);
4819  };
4820 
4821  class AesCmacParams: public Algorithm {
4822  public:
4823  double get_length();
4824  void set_length(double);
4825  };
4826 
4827  class AudioNode: public EventTarget {
4828  public:
4829  double get_channelCount();
4830  void set_channelCount(double);
4831  String* get_channelCountMode();
4832  void set_channelCountMode(const String&);
4833  String* get_channelInterpretation();
4834  void set_channelInterpretation(const String&);
4835  AudioContext* get_context();
4836  double get_numberOfInputs();
4837  double get_numberOfOutputs();
4838  AudioNode* connect(AudioNode* destination);
4839  AudioNode* connect(AudioNode* destination, double output);
4840  AudioNode* connect(AudioNode* destination, double output, double input);
4841  void connect(AudioParam* destination);
4842  void connect(AudioParam* destination, double output);
4843  void disconnect();
4844  void disconnect(double output);
4845  void disconnect(AudioNode* destination);
4846  void disconnect(AudioNode* destination, double output);
4847  void disconnect(AudioNode* destination, double output, double input);
4848  void disconnect(AudioParam* destination);
4849  void disconnect(AudioParam* destination, double output);
4850  AudioNode* get_prototype();
4851  void set_prototype(AudioNode*);
4852  AudioNode();
4853  };
4854 
4855  class AnalyserNode: public AudioNode {
4856  public:
4857  double get_fftSize();
4858  void set_fftSize(double);
4859  double get_frequencyBinCount();
4860  double get_maxDecibels();
4861  void set_maxDecibels(double);
4862  double get_minDecibels();
4863  void set_minDecibels(double);
4864  double get_smoothingTimeConstant();
4865  void set_smoothingTimeConstant(double);
4866  void getByteFrequencyData(Uint8Array* array);
4867  void getByteTimeDomainData(Uint8Array* array);
4868  void getFloatFrequencyData(Float32Array* array);
4869  void getFloatTimeDomainData(Float32Array* array);
4870  AnalyserNode* get_prototype();
4871  void set_prototype(AnalyserNode*);
4872  AnalyserNode();
4873  };
4874 
4875  class Animation: public Object{
4876  public:
4877  double get_currentTime();
4878  void set_currentTime(double);
4879  AnimationEffectReadOnly* get_effect();
4880  void set_effect(AnimationEffectReadOnly*);
4881  Promise* get_finished();
4882  String* get_id();
4883  void set_id(const String&);
4884  bool get_pending();
4885  String* get_playState();
4886  double get_playbackRate();
4887  void set_playbackRate(double);
4888  Promise* get_ready();
4889  double get_startTime();
4890  void set_startTime(double);
4891  AnimationTimeline* get_timeline();
4892  void set_timeline(AnimationTimeline*);
4893  void cancel();
4894  void finish();
4895  EventListener* get_oncancel();
4896  void set_oncancel(EventListener*);
4897  EventListener* get_onfinish();
4898  void set_onfinish(EventListener*);
4899  void pause();
4900  void play();
4901  void reverse();
4902  Animation* get_prototype();
4903  void set_prototype(Animation*);
4904  Animation();
4907  };
4908 
4910  public:
4911  double get_timing();
4912  ComputedTimingProperties* getComputedTiming();
4913  };
4914 
4915  class Event: public Object{
4916  public:
4917  bool get_bubbles();
4918  bool get_cancelBubble();
4919  void set_cancelBubble(bool);
4920  bool get_cancelable();
4921  EventTarget* get_currentTarget();
4922  bool get_defaultPrevented();
4923  double get_eventPhase();
4924  bool get_isTrusted();
4925  bool get_returnValue();
4926  void set_returnValue(bool);
4927  bool get_scoped();
4928  Element* get_srcElement();
4929  EventTarget* get_target();
4930  double get_timeStamp();
4931  String* get_type();
4932  Array* deepPath();
4933  void initEvent(const String& type);
4934  void initEvent(const String& type, bool bubbles);
4935  void initEvent(const String& type, bool bubbles, bool cancelable);
4936  void preventDefault();
4937  void stopImmediatePropagation();
4938  void stopPropagation();
4939  Event* get_prototype();
4940  void set_prototype(Event*);
4941  Event(const String& typeArg);
4942  Event(const String& typeArg, EventInit* eventInitDict);
4943  double get_AT_TARGET();
4944  double get_BUBBLING_PHASE();
4945  double get_CAPTURING_PHASE();
4946  double get_NONE();
4947  };
4948 
4949  class AnimationEvent: public Event {
4950  public:
4951  String* get_animationName();
4952  double get_elapsedTime();
4953  AnimationEvent* get_prototype();
4954  void set_prototype(AnimationEvent*);
4955  AnimationEvent(const String& typeArg);
4956  AnimationEvent(const String& typeArg, AnimationEventInit* eventInitDict);
4957  };
4958 
4959  class AnimationKeyFrame: public Object{
4960  public:
4961  String* get_easing();
4962  void set_easing(const String&);
4963  double get_offset();
4964  void set_offset(double);
4965  Object*& operator[](int index)
4966  {
4967  return __builtin_cheerp_make_regular<Object*>(this, 0)[index];
4968  }
4969  Object* operator[](int index) const
4970  {
4971  return __builtin_cheerp_make_regular<Object*>(this, 0)[index];
4972  }
4973  };
4974 
4975  class AnimationOptions: public Object{
4976  public:
4977  double get_delay();
4978  void set_delay(double);
4979  String* get_direction();
4980  void set_direction(const String&);
4981  double get_duration();
4982  void set_duration(double);
4983  String* get_easing();
4984  void set_easing(const String&);
4985  double get_endDelay();
4986  void set_endDelay(double);
4987  String* get_fill();
4988  void set_fill(const String&);
4989  String* get_id();
4990  void set_id(const String&);
4991  double get_iterationStart();
4992  void set_iterationStart(double);
4993  double get_iterations();
4994  void set_iterations(double);
4995  };
4996 
4998  public:
4999  double get_currentTime();
5000  double get_timelineTime();
5001  AnimationPlaybackEvent* get_prototype();
5002  void set_prototype(AnimationPlaybackEvent*);
5003  AnimationPlaybackEvent(const String& type);
5004  AnimationPlaybackEvent(const String& type, AnimationPlaybackEventInit* eventInitDict);
5005  };
5006 
5008  public:
5009  double get_currentTime();
5010  void set_currentTime(double);
5011  double get_timelineTime();
5012  void set_timelineTime(double);
5013  };
5014 
5015  class AnimationTimeline: public Object{
5016  public:
5017  double get_currentTime();
5018  };
5019 
5021  public:
5022  Event* get_cached();
5023  void set_cached(Event*);
5024  Event* get_checking();
5025  void set_checking(Event*);
5026  Event* get_downloading();
5027  void set_downloading(Event*);
5028  Event* get_error();
5029  void set_error(Event*);
5030  Event* get_noupdate();
5031  void set_noupdate(Event*);
5032  Event* get_obsolete();
5033  void set_obsolete(Event*);
5034  ProgressEvent* get_progress();
5035  void set_progress(ProgressEvent*);
5036  Event* get_updateready();
5037  void set_updateready(Event*);
5038  };
5039 
5041  public:
5042  EventListener* get_oncached();
5043  void set_oncached(EventListener*);
5044  EventListener* get_onchecking();
5045  void set_onchecking(EventListener*);
5046  EventListener* get_ondownloading();
5047  void set_ondownloading(EventListener*);
5048  EventListener* get_onerror();
5049  void set_onerror(EventListener*);
5050  EventListener* get_onnoupdate();
5051  void set_onnoupdate(EventListener*);
5052  EventListener* get_onobsolete();
5053  void set_onobsolete(EventListener*);
5054  EventListener* get_onprogress();
5055  void set_onprogress(EventListener*);
5056  EventListener* get_onupdateready();
5057  void set_onupdateready(EventListener*);
5058  double get_status();
5059  void abort();
5060  void swapCache();
5061  void update();
5062  void addEventListener(const String& type, EventListener* listener);
5063  void addEventListener(const String& type, EventListener* listener, bool options);
5064  void addEventListener(const String& type, EventListener* listener, AddEventListenerOptions* options);
5065  void addEventListener(const String& type, EventListenerObject* listener);
5066  void addEventListener(const String& type, EventListenerObject* listener, AddEventListenerOptions* options);
5067  void removeEventListener(const String& type, EventListener* listener);
5068  void removeEventListener(const String& type, EventListener* listener, bool options);
5069  void removeEventListener(const String& type, EventListener* listener, EventListenerOptions* options);
5070  void removeEventListener(const String& type, EventListenerObject* listener);
5071  void removeEventListener(const String& type, EventListenerObject* listener, EventListenerOptions* options);
5072  ApplicationCache* get_prototype();
5073  void set_prototype(ApplicationCache*);
5074  ApplicationCache();
5075  double get_CHECKING();
5076  double get_DOWNLOADING();
5077  double get_IDLE();
5078  double get_OBSOLETE();
5079  double get_UNCACHED();
5080  double get_UPDATEREADY();
5081  };
5082 
5084  public:
5085  bool get_flatten();
5086  void set_flatten(bool);
5087  };
5088 
5089  class Node: public EventTarget {
5090  public:
5091  String* get_baseURI();
5092  NodeListOf<Node>* get_childNodes();
5093  Node* get_firstChild();
5094  bool get_isConnected();
5095  Node* get_lastChild();
5096  String* get_localName();
5097  String* get_namespaceURI();
5098  Node* get_nextSibling();
5099  String* get_nodeName();
5100  double get_nodeType();
5101  String* get_nodeValue();
5102  void set_nodeValue(const String&);
5103  Document* get_ownerDocument();
5104  HTMLElement* get_parentElement();
5105  Node* get_parentNode();
5106  Node* get_previousSibling();
5107  String* get_textContent();
5108  void set_textContent(const String&);
5109  Node* appendChild(Node* newChild);
5110  Node* cloneNode();
5111  Node* cloneNode(bool deep);
5112  double compareDocumentPosition(Node* other);
5113  bool contains(Node* child);
5114  bool hasChildNodes();
5115  Node* insertBefore(Node* newChild, Node* refChild);
5116  bool isDefaultNamespace(const String& namespaceURI);
5117  bool isEqualNode(Node* arg);
5118  bool isSameNode(Node* other);
5119  String* lookupNamespaceURI(const String& prefix);
5120  String* lookupPrefix(const String& namespaceURI);
5121  void normalize();
5122  Node* removeChild(Node* oldChild);
5123  Node* replaceChild(Node* newChild, Node* oldChild);
5124  Node* get_prototype();
5125  void set_prototype(Node*);
5126  Node();
5127  double get_ATTRIBUTE_NODE();
5128  double get_CDATA_SECTION_NODE();
5129  double get_COMMENT_NODE();
5130  double get_DOCUMENT_FRAGMENT_NODE();
5131  double get_DOCUMENT_NODE();
5132  double get_DOCUMENT_POSITION_CONTAINED_BY();
5133  double get_DOCUMENT_POSITION_CONTAINS();
5134  double get_DOCUMENT_POSITION_DISCONNECTED();
5135  double get_DOCUMENT_POSITION_FOLLOWING();
5136  double get_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC();
5137  double get_DOCUMENT_POSITION_PRECEDING();
5138  double get_DOCUMENT_TYPE_NODE();
5139  double get_ELEMENT_NODE();
5140  double get_ENTITY_NODE();
5141  double get_ENTITY_REFERENCE_NODE();
5142  double get_NOTATION_NODE();
5143  double get_PROCESSING_INSTRUCTION_NODE();
5144  double get_TEXT_NODE();
5145  };
5146 
5147  class Attr: public Node {
5148  public:
5149  String* get_name();
5150  Element* get_ownerElement();
5151  String* get_prefix();
5152  bool get_specified();
5153  String* get_value();
5154  void set_value(const String&);
5155  Attr* get_prototype();
5156  void set_prototype(Attr*);
5157  Attr();
5158  };
5159 
5160  class AudioBuffer: public Object{
5161  public:
5162  double get_duration();
5163  double get_length();
5164  double get_numberOfChannels();
5165  double get_sampleRate();
5166  void copyFromChannel(Float32Array* destination, double channelNumber);
5167  void copyFromChannel(Float32Array* destination, double channelNumber, double startInChannel);
5168  void copyToChannel(Float32Array* source, double channelNumber);
5169  void copyToChannel(Float32Array* source, double channelNumber, double startInChannel);
5170  Float32Array* getChannelData(double channel);
5171  AudioBuffer* get_prototype();
5172  void set_prototype(AudioBuffer*);
5173  AudioBuffer();
5174  };
5175 
5177  public:
5178  Event* get_ended();
5179  void set_ended(Event*);
5180  };
5181 
5183  public:
5184  AudioBuffer* get_buffer();
5185  void set_buffer(AudioBuffer*);
5186  AudioParam* get_detune();
5187  bool get_loop();
5188  void set_loop(bool);
5189  double get_loopEnd();
5190  void set_loopEnd(double);
5191  double get_loopStart();
5192  void set_loopStart(double);
5193  EventListener* get_onended();
5194  void set_onended(EventListener*);
5195  AudioParam* get_playbackRate();
5196  void start();
5197  void start(double when);
5198  void start(double when, double offset);
5199  void start(double when, double offset, double duration);
5200  void stop();
5201  void stop(double when);
5202  void addEventListener(const String& type, EventListener* listener);
5203  void addEventListener(const String& type, EventListener* listener, bool options);
5204  void addEventListener(const String& type, EventListener* listener, AddEventListenerOptions* options);
5205  void addEventListener(const String& type, EventListenerObject* listener);
5206  void addEventListener(const String& type, EventListenerObject* listener, AddEventListenerOptions* options);
5207  void removeEventListener(const String& type, EventListener* listener);
5208  void removeEventListener(const String& type, EventListener* listener, bool options);
5209  void removeEventListener(const String& type, EventListener* listener, EventListenerOptions* options);
5210  void removeEventListener(const String& type, EventListenerObject* listener);
5211  void removeEventListener(const String& type, EventListenerObject* listener, EventListenerOptions* options);
5212  AudioBufferSourceNode* get_prototype();
5213  void set_prototype(AudioBufferSourceNode*);
5215  };
5216 
5218  public:
5219  Event* get_statechange();
5220  void set_statechange(Event*);
5221  };
5222 
5224  public:
5225  double get_currentTime();
5226  AudioDestinationNode* get_destination();
5227  AudioListener* get_listener();
5228  EventListener* get_onstatechange();
5229  void set_onstatechange(EventListener*);
5230  double get_sampleRate();
5231  String* get_state();
5232  Promise* close();
5233  AnalyserNode* createAnalyser();
5234  BiquadFilterNode* createBiquadFilter();
5235  AudioBuffer* createBuffer(double numberOfChannels, double length, double sampleRate);
5236  AudioBufferSourceNode* createBufferSource();
5237  ChannelMergerNode* createChannelMerger();
5238  ChannelMergerNode* createChannelMerger(double numberOfInputs);
5239  ChannelSplitterNode* createChannelSplitter();
5240  ChannelSplitterNode* createChannelSplitter(double numberOfOutputs);
5241  ConvolverNode* createConvolver();
5242  DelayNode* createDelay();
5243  DelayNode* createDelay(double maxDelayTime);
5244  DynamicsCompressorNode* createDynamicsCompressor();
5245  GainNode* createGain();
5246  IIRFilterNode* createIIRFilter(Array* feedforward, Array* feedback);
5247  MediaElementAudioSourceNode* createMediaElementSource(HTMLMediaElement* mediaElement);
5248  MediaStreamAudioSourceNode* createMediaStreamSource(MediaStream* mediaStream);
5249  OscillatorNode* createOscillator();
5250  PannerNode* createPanner();
5251  PeriodicWave* createPeriodicWave(Float32Array* real, Float32Array* imag);
5252  PeriodicWave* createPeriodicWave(Float32Array* real, Float32Array* imag, PeriodicWaveConstraints* constraints);
5253  ScriptProcessorNode* createScriptProcessor();
5254  ScriptProcessorNode* createScriptProcessor(double bufferSize);
5255  ScriptProcessorNode* createScriptProcessor(double bufferSize, double numberOfInputChannels);
5256  ScriptProcessorNode* createScriptProcessor(double bufferSize, double numberOfInputChannels, double numberOfOutputChannels);
5257  StereoPannerNode* createStereoPanner();
5258  WaveShaperNode* createWaveShaper();
5259  Promise* decodeAudioData(ArrayBuffer* audioData);
5260  Promise* decodeAudioData(ArrayBuffer* audioData, EventListener* successCallback);
5261  Promise* decodeAudioData(ArrayBuffer* audioData, EventListener* successCallback, EventListener* errorCallback);
5262  Promise* resume();
5263  void addEventListener(const String& type, EventListener* listener);
5264  void addEventListener(const String& type, EventListener* listener, bool options);
5265  void addEventListener(const String& type, EventListener* listener, AddEventListenerOptions* options);
5266  void addEventListener(const String& type, EventListenerObject* listener);
5267  void addEventListener(const String& type, EventListenerObject* listener, AddEventListenerOptions* options);
5268  void removeEventListener(const String& type, EventListener* listener);
5269  void removeEventListener(const String& type, EventListener* listener, bool options);
5270  void removeEventListener(const String& type, EventListener* listener, EventListenerOptions* options);
5271  void removeEventListener(const String& type, EventListenerObject* listener);
5272  void removeEventListener(const String& type, EventListenerObject* listener, EventListenerOptions* options);
5273  };
5274 
5276  public:
5277  Promise* suspend();
5278  AudioContext* get_prototype();
5279  void set_prototype(AudioContext*);
5280  AudioContext();
5281  };
5282 
5284  public:
5285  double get_maxChannelCount();
5286  AudioDestinationNode* get_prototype();
5287  void set_prototype(AudioDestinationNode*);
5289  };
5290 
5291  class AudioListener: public Object{
5292  public:
5293  double get_dopplerFactor();
5294  void set_dopplerFactor(double);
5295  double get_speedOfSound();
5296  void set_speedOfSound(double);
5297  void setOrientation(double x, double y, double z, double xUp, double yUp, double zUp);
5298  void setPosition(double x, double y, double z);
5299  void setVelocity(double x, double y, double z);
5300  AudioListener* get_prototype();
5301  void set_prototype(AudioListener*);
5302  AudioListener();
5303  };
5304 
5305  class AudioParam: public Object{
5306  public:
5307  double get_defaultValue();
5308  double get_value();
5309  void set_value(double);
5310  AudioParam* cancelScheduledValues(double cancelTime);
5311  AudioParam* exponentialRampToValueAtTime(double value, double endTime);
5312  AudioParam* linearRampToValueAtTime(double value, double endTime);
5313  AudioParam* setTargetAtTime(double target, double startTime, double timeConstant);
5314  AudioParam* setValueAtTime(double value, double startTime);
5315  AudioParam* setValueCurveAtTime(Array* values, double startTime, double duration);
5316  AudioParam* get_prototype();
5317  void set_prototype(AudioParam*);
5318  AudioParam();
5319  };
5320 
5321  class AudioProcessingEvent: public Event {
5322  public:
5323  AudioBuffer* get_inputBuffer();
5324  AudioBuffer* get_outputBuffer();
5325  double get_playbackTime();
5326  AudioProcessingEvent* get_prototype();
5327  void set_prototype(AudioProcessingEvent*);
5329  };
5330 
5331  class AudioTrack: public Object{
5332  public:
5333  bool get_enabled();
5334  void set_enabled(bool);
5335  String* get_id();
5336  String* get_kind();
5337  void set_kind(const String&);
5338  String* get_label();
5339  String* get_language();
5340  void set_language(const String&);
5341  SourceBuffer* get_sourceBuffer();
5342  AudioTrack* get_prototype();
5343  void set_prototype(AudioTrack*);
5344  AudioTrack();
5345  };
5346 
5348  public:
5349  TrackEvent* get_addtrack();
5350  void set_addtrack(TrackEvent*);
5351  Event* get_change();
5352  void set_change(Event*);
5353  TrackEvent* get_removetrack();
5354  void set_removetrack(TrackEvent*);
5355  };
5356 
5357  class AudioTrackList: public EventTarget {
5358  public:
5359  double get_length();
5360  EventListener* get_onaddtrack();
5361  void set_onaddtrack(EventListener*);
5362  EventListener* get_onchange();
5363  void set_onchange(EventListener*);
5364  EventListener* get_onremovetrack();
5365  void set_onremovetrack(EventListener*);
5366