# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at https://mozilla.org/MPL/2.0/.

# DOM Bindings Configuration.
#
# The WebIDL interfaces are defined in dom/webidls. For each such interface,
# there is a corresponding entry in the configuration table below.
# The configuration table maps each interface name to a |descriptor|.
#
# Valid fields for all descriptors:
#   * outerObjectHook: string to use in place of default value for outerObject and thisObject
#                      JS class hooks

DOMInterfaces = {

'AbstractRange': {
    'weakReferenceable': True,
},

'Attr': {
    'canGc':['SetValue'],
},

'AudioBuffer': {
    'canGc':['CopyToChannel', 'GetChannelData'],
},

'AudioContext': {
    'inRealms': ['Close', 'Suspend'],
    'canGc':['CreateMediaStreamDestination', 'CreateMediaElementSource', 'CreateMediaStreamSource', 'CreateMediaStreamTrackSource', 'Suspend', 'Close'],
},

'BaseAudioContext': {
    'inRealms': ['DecodeAudioData', 'Resume', 'ParseFromString', 'GetBounds', 'GetClientRects'],
    'canGc': ['CreateChannelMerger', 'CreateOscillator', 'CreateStereoPanner', 'CreateGain', 'CreateIIRFilter', 'CreateBiquadFilter', 'CreateBufferSource', 'CreateAnalyser', 'CreatePanner', 'CreateChannelSplitter', 'CreateBuffer', 'CreateConstantSource', 'Resume', 'DecodeAudioData', 'Destination', 'Listener'],
},

'Blob': {
    'weakReferenceable': True,
    'canGc': ['Slice', 'Text', 'ArrayBuffer', 'Stream', 'Bytes'],
    'inRealms': ['Bytes'],
},

'Bluetooth': {
    'inRealms': ['GetAvailability', 'RequestDevice'],
    'canGc': ['RequestDevice', 'GetAvailability'],
},

'BluetoothDevice': {
    'inRealms': ['WatchAdvertisements'],
    'canGc': ['WatchAdvertisements'],
},

'BluetoothRemoteGATTCharacteristic': {
    'inRealms': ['ReadValue', 'StartNotifications', 'StopNotifications', 'WriteValue'],
    'canGc': ['GetDescriptor', 'GetDescriptors', 'ReadValue', 'StartNotifications', 'StopNotifications', 'WriteValue'],
},

'BluetoothRemoteGATTDescriptor': {
    'inRealms': ['ReadValue', 'WriteValue'],
    'canGc': ['ReadValue', 'WriteValue'],
},

'BluetoothRemoteGATTServer': {
    'inRealms': ['Connect'],
    'canGc': ['GetPrimaryService', 'GetPrimaryServices', 'Connect', 'Disconnect'],
},

'BluetoothRemoteGATTService': {
    'canGc': ['GetCharacteristic', 'GetCharacteristics', 'GetIncludedService', 'GetIncludedServices'],
},

'ByteLengthQueuingStrategy': {
    'canGc': ['GetSize'],
},

'CanvasGradient': {
    'canGc': ['AddColorStop'],
},

'CanvasRenderingContext2D': {
    'canGc': ['GetTransform','GetImageData', 'CreateImageData', 'CreateImageData_', 'SetFont', 'FillText', 'MeasureText', 'SetStrokeStyle', 'SetFillStyle', 'SetShadowColor', 'CreateLinearGradient', 'CreatePattern', 'CreateRadialGradient'],
},

'CharacterData': {
    'canGc': ['Before', 'After', 'Remove', 'ReplaceWith']
},

'Clipboard': {
    'canGc': ['WriteText']
},

'ClipboardItem': {
    'canGc': ['Types']
},

'CountQueuingStrategy': {
    'canGc': ['GetSize'],
},

'CSSGroupingRule': {
    'canGc': ['CssRules', 'DeleteRule', 'InsertRule'],
},

'CSSKeyframeRule': {
    'canGc': ['Style'],
},

'CSSKeyframesRule': {
    'canGc': ['AppendRule', 'CssRules', 'DeleteRule', 'FindRule'],
},

'CSSLayerStatementRule': {
    'canGc': ['NameList'],
},

'CSSMediaRule': {
    'canGc': ['Media'],
},

'CSSNestedDeclarations': {
    'canGc': ['Style'],
},

'CSSRuleList': {
    'canGc': ['Item', 'IndexedGetter'],
},

'CSSStyleRule': {
    'canGc': ['Style'],
},

'CSSStyleSheet': {
   'canGc': ['AddRule', 'DeleteRule', 'GetCssRules', 'GetRules', 'InsertRule', 'RemoveRule'],
},

'Crypto': {
    'canGc': ['Subtle'],
},

'CSSStyleDeclaration': {
    'canGc': ['RemoveProperty', 'SetCssText', 'GetPropertyValue', 'SetProperty', 'CssFloat', 'SetCssFloat']
},

'CustomElementRegistry': {
    'inRealms': ['WhenDefined'],
    'canGc': ['Define', 'WhenDefined'],
},

'DataTransfer': {
    'canGc': ['Files', 'Types']
},

'DataTransferItem': {
    'canGc': ['GetAsFile']
},

'DataTransferItemList': {
    'canGc': ['IndexedGetter', 'Add', 'Add_']
},

'Document': {
    'additionalTraits': ["crate::interfaces::DocumentHelpers"],
    'canGc': ['Close', 'CreateElement', 'CreateElementNS', 'ImportNode', 'SetTitle', 'Write', 'Writeln', 'CreateEvent', 'CreateRange', 'Open', 'Open_', 'CreateComment', 'CreateAttribute', 'CreateAttributeNS', 'CreateDocumentFragment', 'CreateTextNode', 'CreateCDATASection', 'CreateProcessingInstruction', 'Prepend', 'Append', 'ReplaceChildren', 'SetBgColor', 'SetFgColor', 'Fonts', 'ElementFromPoint', 'ElementsFromPoint', 'ExitFullscreen', 'CreateExpression', 'CreateNSResolver', 'Evaluate', 'StyleSheets', 'Implementation', 'GetElementsByTagName', 'GetElementsByTagNameNS', 'GetElementsByClassName', 'AdoptNode', 'CreateNodeIterator', 'SetBody', 'GetElementsByName', 'Images', 'Embeds', 'Plugins', 'Links', 'Forms', 'Scripts', 'Anchors', 'Applets', 'Children', 'GetSelection'],
},

'DissimilarOriginWindow': {
    'canGc': ['Location']
},

'DocumentFragment': {
    'canGc': ['Prepend', 'Append', 'ReplaceChildren', 'Children']
},

'DocumentType': {
    'canGc': ['Before', 'After', 'Remove', 'ReplaceWith']
},

'DOMImplementation': {
    'canGc': ['CreateDocument', 'CreateHTMLDocument', 'CreateDocumentType'],
},

'DOMMatrix': {
    'canGc': ['FromMatrix', 'FromFloat32Array', 'FromFloat64Array'],
},

'DOMMatrixReadOnly': {
    'canGc': ['Multiply', 'Inverse', 'Scale', 'Translate', 'Rotate', 'RotateFromVector','FlipY', 'ScaleNonUniform', 'Scale3d', 'RotateAxisAngle', 'SkewX', 'SkewY', 'FlipX', 'TransformPoint', 'FromFloat32Array', 'FromFloat64Array', 'FromMatrix', 'ToFloat32Array', 'ToFloat64Array'],
},

'DOMParser': {
    'canGc': ['ParseFromString'],
},

'DOMPoint': {
    'canGc': ['FromPoint'],
},

'DOMPointReadOnly': {
    'canGc': ['FromPoint'],
},

'DOMQuad': {
    'canGc': ['FromRect', 'FromQuad', 'GetBounds'],
},

'DOMRect': {
    'canGc': ['FromRect'],
},

'DOMRectReadOnly': {
    'canGc': ['FromRect'],
},

'DOMStringMap': {
    'canGc': ['NamedDeleter', 'NamedSetter']
},

"DOMTokenList": {
     'canGc': ['SetValue', 'Add', 'Remove', 'Toggle', 'Replace']
},

'DynamicModuleOwner': {
    'inRealms': ['PromiseAttribute'],
},

'Element': {
    'canGc': ['SetHTMLUnsafe', 'SetInnerHTML', 'SetOuterHTML', 'InsertAdjacentHTML', 'GetClientRects', 'GetBoundingClientRect', 'InsertAdjacentText', 'ToggleAttribute', 'SetAttribute', 'SetAttributeNS', 'SetId','SetClassName','Prepend','Append','ReplaceChildren','Before','After','ReplaceWith', 'SetRole', 'SetAriaAtomic', 'SetAriaAutoComplete', 'SetAriaBrailleLabel', 'SetAriaBrailleRoleDescription', 'SetAriaBusy', 'SetAriaChecked', 'SetAriaColCount', 'SetAriaColIndex', 'SetAriaColIndexText', 'SetAriaColSpan', 'SetAriaCurrent', 'SetAriaDescription', 'SetAriaDisabled', 'SetAriaExpanded', 'SetAriaHasPopup', 'SetAriaHidden', 'SetAriaInvalid', 'SetAriaKeyShortcuts', 'SetAriaLabel', 'SetAriaLevel', 'SetAriaLive', 'SetAriaModal', 'SetAriaMultiLine', 'SetAriaMultiSelectable', 'SetAriaOrientation', 'SetAriaPlaceholder', 'SetAriaPosInSet', 'SetAriaPressed','SetAriaReadOnly', 'SetAriaRelevant', 'SetAriaRequired', 'SetAriaRoleDescription', 'SetAriaRowCount', 'SetAriaRowIndex', 'SetAriaRowIndexText', 'SetAriaRowSpan', 'SetAriaSelected', 'SetAriaSetSize','SetAriaSort', 'SetAriaValueMax', 'SetAriaValueMin', 'SetAriaValueNow', 'SetAriaValueText', 'SetScrollTop', 'SetScrollLeft', 'Scroll', 'Scroll_', 'ScrollBy', 'ScrollBy_', 'ScrollWidth', 'ScrollHeight', 'ScrollTop', 'ScrollLeft', 'ClientTop', 'ClientLeft', 'ClientWidth', 'ClientHeight', 'RequestFullscreen', 'GetHTML', 'GetInnerHTML', 'GetOuterHTML', 'ClassList', 'Attributes', 'SetAttributeNode', 'SetAttributeNodeNS', 'RemoveAttribute', 'RemoveAttributeNS', 'RemoveAttributeNode', 'GetElementsByTagName', 'GetElementsByTagNameNS', 'GetElementsByClassName', 'ScrollTo', 'ScrollTo_', 'Children', 'Remove', 'InsertAdjacentElement', 'AttachShadow'],
},

'ElementInternals': {
    'canGc': ['CheckValidity', 'GetLabels', 'SetValidity', 'ReportValidity'],
},

'EventSource': {
    'weakReferenceable': True,
},

'EventTarget': {
    'canGc': ['DispatchEvent'],
},

'ExtendableMessageEvent': {
    'canGc': ['Ports'],
},

'FakeXRDevice': {
    'canGc': ['Disconnect'],
},

'File': {
    'weakReferenceable': True,
},

'FileReader': {
    'canGc': ['Abort', 'ReadAsArrayBuffer', 'ReadAsDataURL', 'ReadAsText'],
    'inRealms': ['ReadAsArrayBuffer', 'ReadAsDataURL', 'ReadAsText'],
},

'FileReaderSync': {
    'canGc': ['ReadAsArrayBuffer'],
},

'FontFaceSet': {
    'canGc': ['Load'],
},

'GamepadHapticActuator': {
    'inRealms': ['PlayEffect', 'Reset'],
    'canGc': ['PlayEffect', 'Reset', 'Effects'],
},

'GlobalScope': {
    'additionalTraits': ['crate::interfaces::GlobalScopeHelpers<Self>'],
},

'GPU': {
    'inRealms': ['RequestAdapter'],
    'canGc': ['RequestAdapter', 'WgslLanguageFeatures'],
},

'GPUAdapter': {
    'inRealms': ['RequestAdapterInfo', 'RequestDevice'],
    'canGc': ['RequestAdapterInfo', 'RequestDevice'],
},

'GPUBuffer': {
    'inRealms': ['MapAsync'],
    'canGc': ['GetMappedRange', 'MapAsync'],
},

'GPUCanvasContext': {
    'weakReferenceable': True,
},

'GPUCompilationInfo': {
    'canGc': ['Messages'],
},

'GPUDevice': {
    'inRealms': [
        'CreateComputePipelineAsync',
        'CreateRenderPipelineAsync',
        'CreateShaderModule', # Creates promise for compilation info
        'PopErrorScope'
    ],
    'canGc': [
        'CreateComputePipelineAsync',
        'CreateRenderPipelineAsync',
        'CreateShaderModule',
        'PopErrorScope'
    ],
    'weakReferenceable': True, # for usage in GlobalScope https://github.com/servo/servo/issues/32519
},

'GPUQueue': {
    'canGc': ['OnSubmittedWorkDone'],
},

'History': {
    'canGc': ['Go'],
},

"HTMLAnchorElement": {
    "canGc": ["SetText","SetRel","SetHref", 'SetHash', 'SetHost', 'SetHostname', 'SetPassword', 'SetPathname', 'SetPort', 'SetProtocol', 'SetSearch', 'SetUsername', 'RelList']
},

"HTMLAreaElement": {
     "canGc": ['SetText', 'SetRel', 'SetHref', 'SetHash', 'SetHost', 'SetHostname', 'SetPassword', 'SetPathname', 'SetPort', 'SetProtocol', 'SetSearch', 'SetUsername', 'RelList']
},

"HTMLBodyElement": {
    "canGc": ["SetBackground"]
},

'HTMLButtonElement': {
    'canGc': ['CheckValidity', 'ReportValidity','SetBackground'],
},

'HTMLCanvasElement': {
    'canGc': ['CaptureStream', 'GetContext', 'SetHeight', 'SetWidth', 'TransferControlToOffscreen'],
},

'HTMLDataListElement': {
    "canGc": ["Options"]
},

'HTMLDialogElement': {
    'canGc': ['Close', 'Show'],
},

'HTMLElement': {
    'canGc': ['AttachInternals', 'Focus', 'Blur', 'Click', 'SetInnerText', 'SetOuterText', "SetTranslate", 'SetAutofocus', 'GetOffsetParent', 'OffsetTop', 'OffsetLeft', 'OffsetWidth', 'OffsetHeight', 'InnerText', 'GetOuterText', 'GetOnerror', 'GetOnload', 'GetOnblur', 'GetOnfocus', 'GetOnresize', 'GetOnscroll', 'Style', 'Dataset'],
},

'HTMLFieldSetElement': {
    'canGc': ['CheckValidity', 'Elements', 'ReportValidity'],
},

'HTMLFontElement': {
    'canGc': ['SetSize']
},

'HTMLFormControlsCollection': {
    'canGc': ['NamedGetter', 'NamedItem'],
},

'HTMLFormElement': {
    'canGc': ['CheckValidity', 'Elements', 'IndexedGetter', 'NamedGetter', 'RequestSubmit', 'ReportValidity', 'Submit', 'Reset', 'SetRel', 'RelList'],
},

'HTMLIFrameElement': {
    'canGc': ['Sandbox'],
},

'HTMLImageElement': {
    'canGc': ['RequestSubmit', 'ReportValidity', 'Reset','SetRel', 'Width', 'Height', 'Decode', 'SetCrossOrigin', 'SetWidth', 'SetHeight', 'SetReferrerPolicy'],
},

'HTMLInputElement': {
    'canGc': ['ReportValidity', 'SetValue', 'SetValueAsNumber', 'SetValueAsDate', 'StepUp', 'StepDown', 'CheckValidity', 'ReportValidity', 'SelectFiles', 'GetLabels'],
},

'HTMLLinkElement': {
    'canGc': ['GetSheet', 'SetRel', 'SetCrossOrigin', 'RelList'],
},

'HTMLMediaElement': {
    'canGc': ['Load', 'Pause', 'Play', 'SetSrcObject', 'SetCrossOrigin'],
    'inRealms': ['Play'],
},

'HTMLMeterElement': {
    'canGc': ['SetValue', 'SetMin', 'SetMax', 'SetLow', 'SetHigh', 'SetOptimum', 'CheckValidity', 'ReportValidity']
},

'HTMLObjectElement': {
    'canGc': ['CheckValidity', 'ReportValidity'],
},

'HTMLOptionElement': {
    'canGc': ['SetText']
},

'HTMLOptionsCollection': {
    'canGc': ['IndexedSetter', 'SetLength', 'SetSelectedIndex']
},

'HTMLOutputElement': {
    'canGc': ['ReportValidity', 'SetDefaultValue', 'SetValue', 'CheckValidity'],
},

'HTMLProgressElement': {
    'canGc': ['SetValue', 'SetMax']
},

'HTMLScriptElement': {
    'canGc': ['SetAsync', 'SetCrossOrigin', 'SetSrc', 'SetText']
},

'HTMLSelectElement': {
    'canGc': ['ReportValidity', 'SetLength', 'IndexedSetter', 'CheckValidity', 'SetSelectedIndex'],
},

'HTMLTableElement': {
    'canGc': ['CreateCaption', 'CreateTBody', 'InsertRow', 'InsertCell', 'InsertRow', 'CreateTHead', 'CreateTFoot']
},

'HTMLTableRowElement': {
    'canGc': ['InsertCell']
},

'HTMLTableSectionElement': {
    'canGc': ['InsertRow']
},

'HTMLTemplateElement': {
    'canGc': ['Content'],
},

'HTMLTextAreaElement': {
    'canGc': ['ReportValidity', 'SetDefaultValue', 'CheckValidity'],
},

'HTMLTitleElement': {
    'canGc': ['SetText']
},

'IntersectionObserver': {
    'canGc': ['Thresholds']
},

'Location': {
    'canGc': ['Assign', 'Reload', 'Replace', 'SetHash', 'SetHost', 'SetHostname', 'SetHref', 'SetPathname', 'SetPort', 'SetProtocol', 'SetSearch'],
},

'MediaDevices': {
    'canGc': ['GetUserMedia', 'EnumerateDevices'],
    'inRealms': ['GetUserMedia', 'GetClientRects', 'GetBoundingClientRect'],
},

'MediaQueryList': {
    'weakReferenceable': True,
},

'MediaSession': {
    'canGc': ['GetMetadata'],
},

'MediaStream': {
    'canGc': ['Clone'],
},

'MessagePort': {
    'weakReferenceable': True,
    'canGc': ['GetOnmessage'],
},

'MessageEvent': {
    'canGc': ['Ports'],
},

'MouseEvent': {
    'canGc': ['OffsetX', 'OffsetY'],
},

'NavigationPreloadManager': {
    'inRealms': ['Disable', 'Enable', 'GetState', 'SetHeaderValue'],
    'canGc': ['Disable', 'Enable', 'GetState', 'SetHeaderValue'],
},

'Navigator': {
    'inRealms': ['GetVRDisplays'],
    'canGc': ['Languages'],
},

'Node': {
    'canGc': ['AppendChild', 'ChildNodes', 'CloneNode', 'InsertBefore', 'Normalize', 'SetNodeValue', 'SetTextContent', 'RemoveChild', 'ReplaceChild'],
},

'NodeIterator': {
    'canGc': ['NextNode', 'PreviousNode'],
},

'Notification': {
    'canGc': ['RequestPermission', 'Actions', 'Vibrate'],
},

'OfflineAudioContext': {
    'inRealms': ['StartRendering'],
    'canGc': ['StartRendering'],
},

'OffscreenCanvas': {
    'canGc': ['GetContext', 'SetHeight', 'SetWidth'],
},

'OffscreenCanvasRenderingContext2D': {
    'canGc': ['CreateImageData', 'CreateImageData_', 'GetImageData', 'GetTransform', 'SetFont', 'FillText', 'MeasureText', 'SetStrokeStyle', 'SetFillStyle', 'SetShadowColor', 'CreateLinearGradient', 'CreatePattern', 'CreateRadialGradient'],
},

'PaintRenderingContext2D': {
    'canGc': ['GetTransform', 'SetStrokeStyle', 'SetFillStyle', 'SetShadowColor'],
},

'Performance': {
    'canGc': ['Mark', 'Measure'],
},

'PerformanceObserver': {
    'canGc': ['SupportedEntryTypes'],
},

'Permissions': {
    'canGc': ['Query', 'Request', 'Revoke'],
},

'Promise': {
    'spiderMonkeyInterface': True,
    'additionalTraits': ["crate::interfaces::PromiseHelpers<Self>", "js::conversions::FromJSValConvertibleRc"]
},

'Range': {
    'canGc': ['CloneContents', 'CloneRange', 'CreateContextualFragment', 'ExtractContents', 'SurroundContents', 'InsertNode', 'GetClientRects', 'GetBoundingClientRect'],
    'weakReferenceable': True,
},

'Request': {
    'canGc': ['Headers', 'Text', 'Blob', 'FormData', 'Json', 'ArrayBuffer', 'Clone', 'Bytes'],
},

'Response': {
    'canGc': ['Error', 'Redirect', 'Clone', 'Text', 'Blob', 'FormData', 'Json', 'ArrayBuffer', 'Headers', 'Bytes'],
},

'RTCPeerConnection': {
    'inRealms': ['AddIceCandidate', 'CreateAnswer', 'CreateOffer', 'SetLocalDescription', 'SetRemoteDescription'],
    'canGc': ['Close', 'AddIceCandidate', 'CreateAnswer', 'CreateOffer', 'SetLocalDescription', 'SetRemoteDescription'],
},

'RTCRtpSender': {
    'canGc': ['SetParameters'],
},

'Selection': {
    'canGc': ['Collapse', 'CollapseToEnd', 'CollapseToStart', 'Extend', 'SelectAllChildren', 'SetBaseAndExtent', 'SetPosition'],
},

'ServiceWorkerContainer': {
    'inRealms': ['Register'],
    'canGc': ['Register'],
},

'ServoInternals': {
    'inRealms': ['ReportMemory'],
    'canGc': ['ReportMemory'],
    'additionalTraits': ['crate::interfaces::ServoInternalsHelpers'],
},

'ShadowRoot': {
    'canGc': ['ElementFromPoint', 'ElementsFromPoint', 'SetInnerHTML', 'GetHTML', 'InnerHTML'],
},

'StaticRange': {
    'weakReferenceable': True,
},

'SubtleCrypto': {
    'inRealms': ['Encrypt', 'Decrypt', 'Sign', 'Verify', 'GenerateKey', 'DeriveKey', 'DeriveBits', 'Digest', 'ImportKey', 'ExportKey', 'WrapKey', 'UnwrapKey'],
    'canGc': ['Encrypt', 'Decrypt', 'Sign', 'Verify', 'GenerateKey', 'DeriveKey', 'DeriveBits', 'Digest', 'ImportKey', 'ExportKey', 'WrapKey', 'UnwrapKey'],
},

'SVGElement': {
    'canGc': ['SetAutofocus']
},

#FIXME(jdm): This should be 'register': False, but then we don't generate enum types
'TestBinding': {
    'inRealms': ['PromiseAttribute', 'PromiseNativeHandler'],
    'canGc': ['InterfaceAttribute', 'GetInterfaceAttributeNullable', 'ReceiveInterface', 'ReceiveInterfaceSequence', 'ReceiveNullableInterface', 'PromiseAttribute', 'PromiseNativeHandler', 'PromiseResolveNative', 'PromiseRejectNative', 'PromiseRejectWithTypeError'],
    'additionalTraits': ['crate::interfaces::TestBindingHelpers'],
},

'TestWorklet': {
    'inRealms': ['AddModule'],
    'canGc': ['AddModule'],
},

'Text': {
    'canGc': ['SplitText']
},

'TextEncoder': {
    'canGc': ['Encode']
},

'TreeWalker': {
    'canGc': ['ParentNode', 'PreviousNode', 'NextNode', 'FirstChild', 'LastChild', 'PreviousSibling', 'NextSibling']
},

'TrustedTypePolicy': {
    'canGc': ['CreateHTML', 'CreateScript', 'CreateScriptURL']
},

'TrustedTypePolicyFactory': {
    'canGc': ['CreatePolicy', 'EmptyHTML', 'EmptyScript']
},

'URL': {
    'weakReferenceable': True,
    'canGc': ['Parse', 'SearchParams'],
},

'WebGLRenderingContext': {
    'canGc': ['MakeXRCompatible'],
},

'WebGL2RenderingContext': {
    'canGc': ['MakeXRCompatible'],
    'additionalTraits': ['crate::interfaces::WebGL2RenderingContextHelpers'],
},

'Window': {
    'canGc': ['Stop', 'Fetch', 'Scroll', 'Scroll_','ScrollBy', 'ScrollBy_', 'Stop', 'Fetch', 'Open', 'CreateImageBitmap', 'TrustedTypes'],
    'inRealms': ['Fetch', 'GetOpener'],
    'additionalTraits': ['crate::interfaces::WindowHelpers'],
},

'WindowProxy' : {
    'path': 'crate::dom::windowproxy::WindowProxy',
    'register': False,
},

'WorkerGlobalScope': {
    'inRealms': ['Fetch'],
    'canGc': ['Fetch', 'CreateImageBitmap', 'ImportScripts', 'TrustedTypes'],
},

'Worklet': {
    'inRealms': ['AddModule'],
    'canGc': ['AddModule'],
},

'XMLHttpRequest': {
    'canGc': ['Abort', 'GetResponseXML', 'Response', 'Send'],
},

'XPathEvaluator': {
    'canGc': ['CreateExpression', 'Evaluate'],
},

'XPathExpression': {
    'canGc': ['Evaluate'],
},

'XRBoundedReferenceSpace': {
    'canGc': ['BoundsGeometry'],
},

'XRFrame': {
    'canGc': ['GetViewerPose', 'GetPose', 'GetJointPose'],
},

'XRHitTestResult': {
    'canGc': ['GetPose'],
},

'XRRay': {
    'canGc': ['Origin', 'Direction', 'Matrix'],
},

'XRReferenceSpace': {
    'canGc': ['GetOffsetReferenceSpace'],
},

'XRRenderState': {
    'canGc': ['Layers'],
},

'XRRigidTransform': {
    'canGc': ['Position', 'Orientation', 'Inverse', 'Matrix'],
},

'XRSession': {
    'inRealms': ['RequestReferenceSpace', 'UpdateRenderState', 'UpdateTargetFrameRate'],
    'canGc': ['End', 'RequestReferenceSpace', 'UpdateTargetFrameRate', 'RequestHitTestSource', 'GetSupportedFrameRates', 'EnabledFeatures'],
},

'XRSystem': {
    'inRealms': ['RequestSession'],
    'canGc': ['RequestSession', 'IsSessionSupported'],
},

'XRTest': {
    'canGc': ['SimulateDeviceConnection', 'DisconnectAllDevices', 'SimulateUserActivation'],
},

'XRView': {
    'canGc': ['ProjectionMatrix'],
},

'ReadableStream': {
    'canGc': ['GetReader', 'Cancel', 'PipeTo', 'Tee'],
    'inRealms': ['PipeTo'],
},

"ReadableStreamDefaultController": {
    "canGc": ["Close", "Enqueue", "Error"]
},

"ReadableByteStreamController": {
    "canGc": ["GetByobRequest", "Enqueue", "Close", "Error"]
},

"ReadableStreamBYOBRequest": {
    "canGc": ["Respond", "RespondWithNewView"]
},

"ReadableStreamBYOBReader": {
    "canGc": ["Cancel", "Read", "ReleaseLock"]
},

"ReadableStreamDefaultReader": {
    "canGc": ["Cancel", "Read", "ReleaseLock"]
},

'ResizeObserverEntry': {
    'canGc': ['BorderBoxSize', 'ContentBoxSize', 'DevicePixelContentBoxSize'],
},

'WritableStream': {
    'canGc': ['Abort', 'Close', 'GetWriter'],
    'inRealms': ['Abort', 'Close', 'GetWriter'],
},

'WritableStreamDefaultController': {
    'canGc': ['Error'],
    'inRealms': ['Error'],
},

'WritableStreamDefaultWriter': {
    'canGc': ['Abort', 'Close', 'Write', 'ReleaseLock'],
    'inRealms': ['Abort', 'Close', 'Write'],
},

'WorkerNavigator': {
    'canGc': ['Languages'],
},

}

Dictionaries = {
'AudioNodeOptions': {
    'derives': ['Clone', 'Copy'],
},

'ChannelMergerOptions': {
    'derives': ['Clone', 'Copy'],
},

'ConstantSourceOptions': {
    'derives': ['Clone', 'Copy'],
},

'FontFaceDescriptors': {
    'derives': ['Clone', 'MallocSizeOf']
},

'GainOptions': {
    'derives': ['Clone', 'Copy'],
},

'GPUCanvasConfiguration': {
    'derives': ['Clone']
},

'GPUExtent3DDict': {
    'derives': ["MallocSizeOf"],
},

'GPUObjectDescriptorBase': {
    'derives': ['MallocSizeOf']
},

'GPUTextureDescriptor': {
    'derives': ["MallocSizeOf"],
},

'HeadersInit': {
    'derives': ["Clone"],
},

'IIRFilterOptions': {
    'derives': ['Clone'],
},

'StereoPannerOptions': {
    'derives': ['Clone', 'Copy'],
},

'URLPatternInit': {
    'derives': ['Clone'],
},

'XRWebGLLayerInit': {
    'derives': ['Clone', 'Copy'],
},
}

Enums = {
'GPUFeatureName': {
    'derives': ['Eq', 'Hash', ]
},
'PermissionName': {
    'derives': ['Eq', 'Hash']
}
}

Unions = {
'ByteStringSequenceSequenceOrByteStringByteStringRecord': {
    'derives': ['Clone']
},

'ElementOrDocument': {
    'derives': ['Clone', 'MallocSizeOf']
},

'HTMLCanvasElementOrOffscreenCanvas': {
    'derives': ['Clone', 'MallocSizeOf']
},

'RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict': {
    'derives': ['MallocSizeOf']
},

'StringOrUnsignedLong': {
    'derives': ['Clone'],
},
}