/*
 * Copyright (C) 2013 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

enum TestEnum {"", "EnumValue1", "EnumValue2", "EnumValue3"};
enum TestEnum2 {"", "EnumValue1", "EnumValue2", "EnumValue3"};

// No extended attributes on the interface; those go in TestInterface.idl
interface TestObject {
    stringifier attribute DOMString stringifierAttribute;

    // Attributes
    //
    // Naming convention:
    // [ExtAttr] attribute Type extAttrTypeNameAttribute;
    // E.g.,
    // [Foo] attribute DOMString? fooStringOrNullAttribute
    //
    // Type name reference:
    // https://heycam.github.io/webidl/#dfn-type-name
    //
    // TestInterfaceEmpty is used as a stub interface type, for testing behavior
    // that should not depend on particular type (beyond "interface or not").
    // read only
    readonly attribute DOMString readonlyStringAttribute;
    readonly attribute TestInterfaceEmpty readonlyTestInterfaceEmptyAttribute;
    readonly attribute long readonlyLongAttribute;
    // Basic types
    attribute Date dateAttribute;
    attribute DOMString stringAttribute;
    attribute ByteString byteStringAttribute;
    attribute USVString usvStringAttribute;
    attribute DOMTimeStamp domTimeStampAttribute;
    attribute boolean booleanAttribute;
    attribute byte byteAttribute;
    attribute double doubleAttribute;
    attribute float floatAttribute;
    attribute long longAttribute;
    attribute long long longLongAttribute;
    attribute octet octetAttribute;
    attribute short shortAttribute;
    attribute unrestricted double unrestrictedDoubleAttribute;
    attribute unrestricted float unrestrictedFloatAttribute;
    attribute unsigned long unsignedLongAttribute;
    attribute unsigned long long unsignedLongLongAttribute;
    attribute unsigned short unsignedShortAttribute;
    // Interface type
    attribute TestInterfaceEmpty testInterfaceEmptyAttribute;
    // Self-reference
    attribute TestObject testObjectAttribute;
    // Names that begin with an acronym
    attribute long cssAttribute;
    attribute long imeAttribute;
    attribute long svgAttribute;
    attribute long xmlAttribute;
    // Non-wrapper types
    attribute NodeFilter nodeFilterAttribute;
    attribute SerializedScriptValue serializedScriptValueAttribute;
    attribute any anyAttribute;
    // Custom type conversions
    attribute Promise promiseAttribute;
    attribute Window windowAttribute;
    // DOM Node types
    attribute Document documentAttribute;
    attribute DocumentFragment documentFragmentAttribute;
    attribute DocumentType documentTypeAttribute;
    attribute Element elementAttribute;
    attribute Node nodeAttribute;
    attribute ShadowRoot shadowRootAttribute;
    // Typed arrays
    attribute ArrayBuffer arrayBufferAttribute;
    attribute Float32Array float32ArrayAttribute;
    attribute Uint8Array uint8ArrayAttribute;
    // Exceptions for is_keep_alive_for_gc
    readonly attribute TestInterfaceEmpty self;
    readonly attribute EventTarget readonlyEventTargetAttribute;
    readonly attribute EventTarget? readonlyEventTargetOrNullAttribute;
    readonly attribute Window readonlyWindowAttribute;
    readonly attribute HTMLCollection htmlCollectionAttribute;
    readonly attribute HTMLElement htmlElementAttribute;
    // FrozenArrays
    attribute FrozenArray<DOMString> stringFrozenArrayAttribute;
    attribute FrozenArray<TestInterfaceEmpty> testInterfaceEmptyFrozenArrayAttribute;
    // Nullable attributes
    attribute boolean? booleanOrNullAttribute;
    attribute DOMString? stringOrNullAttribute;
    attribute long? longOrNullAttribute;
    attribute TestInterface? testInterfaceOrNullAttribute;
    // Enumerations
    attribute TestEnum testEnumAttribute;
    attribute TestEnum? testEnumOrNullAttribute;
    // Static attributes
    static attribute DOMString staticStringAttribute;
    static attribute long staticLongAttribute;
    // Exceptional type
    attribute EventHandler eventHandlerAttribute;
    // Union types
    attribute (double or DOMString) doubleOrStringAttribute;
    attribute (double or DOMString)? doubleOrStringOrNullAttribute;
    attribute (double? or DOMString) doubleOrNullStringAttribute;
    attribute (DOMString or sequence<DOMString>) stringOrStringSequenceAttribute;
    attribute (TestEnum or double) testEnumOrDoubleAttribute;
    attribute (unrestricted double or DOMString) unrestrictedDoubleOrStringAttribute;
    attribute ((double or DOMString) or sequence<(double or DOMString)>) nestedUnionAtribute;

    // Extended attributes
    [LogActivity, LogAllWorlds] attribute long activityLoggingAccessForAllWorldsLongAttribute;
    [LogActivity=GetterOnly, LogAllWorlds] attribute long activityLoggingGetterForAllWorldsLongAttribute;
    [LogActivity=SetterOnly, LogAllWorlds] attribute long activityLoggingSetterForAllWorldsLongAttribute;
    [CachedAttribute=isValueDirty] attribute any cachedAttributeAnyAttribute;
    [CachedAttribute=isFrozenArrayDirty] attribute FrozenArray<DOMString> cachedArrayAttribute;
    [CachedAttribute=isStringDirty] attribute DOMString? cachedStringOrNoneAttribute;
    [CallWith=ExecutionContext] attribute any callWithExecutionContextAnyAttribute;
    [CallWith=ScriptState] attribute any callWithScriptStateAnyAttribute;
    [CallWith=(ExecutionContext,ScriptState)] attribute any callWithExecutionContextAndScriptStateAnyAttribute;
    [CheckSecurity=ReturnValue] readonly attribute Document checkSecurityForNodeReadonlyDocumentAttribute; // All uses are read only
    // Constructors: FIXME: replace suffix with [ConstructorAttribute]
    attribute TestInterfaceEmptyConstructor testInterfaceEmptyConstructorAttribute;
    [DeprecateAs=deprecatedTestInterfaceEmptyConstructorAttribute] attribute TestInterfaceEmptyConstructor testInterfaceEmptyConstructorAttribute;
    [MeasureAs=FeatureName] attribute TestInterfaceEmptyConstructor measureAsFeatureNameTestInterfaceEmptyConstructorAttribute;
    [Custom] attribute object customObjectAttribute;
    [Custom=Getter] attribute long customGetterLongAttribute;
    [Custom=Getter] readonly attribute object customGetterReadonlyObjectAttribute;
    [Custom=Setter] attribute long customSetterLongAttribute;
    [DeprecateAs=LongAttribute] attribute long deprecatedLongAttribute;
    [EnforceRange] attribute long enforceRangeLongAttribute;
    [ImplementedAs=implementedAsName] attribute long implementedAsLongAttribute;
    [Custom, ImplementedAs=implementedAsNameWithCustom] attribute long customImplementedAsLongAttribute;
    [Custom=Getter, ImplementedAs=implementedAsNameWithCustomGetter] attribute long customGetterImplementedAsLongAttribute;
    [Custom=Setter, ImplementedAs=implementedAsNameWithCustomGetter] attribute long customSetterImplementedAsLongAttribute;
    [MeasureAs=TestFeature] attribute long measureAsLongAttribute;
    [NotEnumerable] attribute long notEnumerableLongAttribute;
    [OriginTrialEnabled=FeatureName] attribute long originTrialEnabledLongAttribute;
    [PerWorldBindings] readonly attribute TestInterfaceEmpty perWorldBindingsReadonlyTestInterfaceEmptyAttribute;
    [LogActivity, LogAllWorlds, PerWorldBindings] attribute long activityLoggingAccessPerWorldBindingsLongAttribute;
    [LogActivity, PerWorldBindings] attribute long activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute;
    [LogActivity=GetterOnly, LogAllWorlds, PerWorldBindings] attribute long activityLoggingGetterPerWorldBindingsLongAttribute;
    [LogActivity=GetterOnly, PerWorldBindings] attribute long activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute;
    [PutForwards=href] readonly attribute TestNode location;
    [PutForwards=hrefThrows] readonly attribute TestNode locationWithException;
    [PutForwards=hrefCallWith] readonly attribute TestNode locationWithCallWith;
    [PutForwards=hrefByteString] readonly attribute TestNode locationByteString;
    [PerWorldBindings, PutForwards=href] readonly attribute TestNode locationWithPerWorldBindings;
    [PutForwards=href, LegacyInterfaceTypeChecking] readonly attribute TestNode locationLegacyInterfaceTypeChecking;
    [PutForwards=attr1] readonly attribute TestInterfaceGarbageCollected locationGarbageCollected;
    [RaisesException] attribute long raisesExceptionLongAttribute;
    [RaisesException=Getter] attribute long raisesExceptionGetterLongAttribute;
    [RaisesException=Setter] attribute long setterRaisesExceptionLongAttribute;
    [RaisesException] attribute TestInterfaceEmpty raisesExceptionTestInterfaceEmptyAttribute;
    [CachedAttribute=isValueDirty, RaisesException] attribute any cachedAttributeRaisesExceptionGetterAnyAttribute;
    [Reflect] attribute TestInterface reflectTestInterfaceAttribute;
    [Reflect=reflectedNameAttribute] attribute TestInterface reflectReflectedNameAttributeTestAttribute;
    // [Reflect] exceptional types: exceptional getters, exceptional setters,
    // or range checking for unsigned
    [Reflect] attribute boolean reflectBooleanAttribute;
    [Reflect] attribute long reflectLongAttribute;
    [Reflect] attribute unsigned short reflectUnsignedShortAttribute;
    [Reflect] attribute unsigned long reflectUnsignedLongAttribute;
    // [Reflect] exceptional names
    [Reflect] attribute DOMString id;
    [Reflect] attribute DOMString name;
    [Reflect] attribute DOMString class;
    [Reflect=id] attribute DOMString reflectedId;
    [Reflect=name] attribute DOMString reflectedName;
    [Reflect=class] attribute DOMString reflectedClass;
    // Limited value attributes and enumerated attributes
    [Reflect, ReflectOnly="unique"] attribute DOMString limitedToOnlyOneAttribute;
    [Reflect, ReflectOnly=("Per","Paal","Espen")] attribute DOMString limitedToOnlyAttribute;
    [Reflect=other, ReflectOnly=("Value1","Value2")] attribute DOMString limitedToOnlyOtherAttribute;
    [Reflect, ReflectOnly=("rsa","dsa"), ReflectMissing="rsa"] attribute DOMString limitedWithMissingDefaultAttribute;
    [Reflect, ReflectOnly=("ltr","rtl","auto"), ReflectMissing="auto", ReflectInvalid="ltr"] attribute DOMString limitedWithInvalidMissingDefaultAttribute;
    [Reflect, ReflectOnly=("anonymous","use-credentials"), ReflectEmpty="anonymous", ReflectInvalid="anonymous"] readonly attribute DOMString corsSettingAttribute;
    [Reflect, ReflectOnly=("empty","missing","invalid","a-normal"), ReflectEmpty="empty", ReflectMissing="missing", ReflectInvalid="invalid"] readonly attribute DOMString limitedWithEmptyMissingInvalidAttribute;
    [RuntimeCallStatsCounter=RuntimeCallStatsCounterAttribute] attribute long RuntimeCallStatsCounterAttribute;
    [RuntimeCallStatsCounter=RuntimeCallStatsCounterReadOnlyAttribute] readonly attribute double RuntimeCallStatsCounterReadOnlyAttribute;

    [Replaceable] readonly attribute long replaceableReadonlyLongAttribute;
    [PutForwards=href] readonly attribute TestNode locationPutForwards;
    [RuntimeEnabled=FeatureName] attribute long runtimeEnabledLongAttribute;
    [SetterCallWith=(CurrentWindow,EnteredWindow)] attribute DOMString setterCallWithCurrentWindowAndEnteredWindowStringAttribute;
    [SetterCallWith=ExecutionContext] attribute DOMString setterCallWithExecutionContextStringAttribute;
    attribute [TreatNullAs=EmptyString] DOMString treatNullAsEmptyStringStringAttribute;
    attribute [TreatNullAs=NullString] DOMString treatNullAsNullStringStringAttribute;
    [LegacyInterfaceTypeChecking] attribute float legacyInterfaceTypeCheckingFloatAttribute; // nop for non-interface types
    [LegacyInterfaceTypeChecking] attribute TestInterface legacyInterfaceTypeCheckingTestInterfaceAttribute;
    [LegacyInterfaceTypeChecking] attribute TestInterface? legacyInterfaceTypeCheckingTestInterfaceOrNullAttribute;
    [Reflect, URL] attribute DOMString urlStringAttribute;
    [Reflect=reflectUrlAttribute, URL] attribute DOMString urlStringAttribute;
    [Unforgeable] attribute long unforgeableLongAttribute;
    [Measure] attribute long measuredLongAttribute;
    [SameObject] readonly attribute TestInterface sameObjectAttribute;
    [SameObject, SaveSameObject] readonly attribute TestInterface saveSameObjectAttribute;
    [SameObject, SaveSameObject] static readonly attribute TestInterface staticSaveSameObjectAttribute;
    [Unscopable] attribute long unscopableLongAttribute;
    [Unscopable, OriginTrialEnabled=FeatureName] attribute long unscopableOriginTrialEnabledLongAttribute;
    [Unscopable, RuntimeEnabled=FeatureName] attribute long unscopableRuntimeEnabledLongAttribute;
    [Unscopable] void unscopableVoidMethod();
    [Unscopable, RuntimeEnabled=FeatureName] void unscopableRuntimeEnabledVoidMethod();

    // Methods
    //
    // Naming convention:
    // ReturnType returnTypeMethodTypeName1ArgTypeName2Arg(Type1 typeName1Arg, Type2 typeName2Arg);
    // E.g.,
    // void voidMethodStringArgLongSequenceArg(DOMString stringArg, sequence<long> longSequenceArg);
    void voidMethod();
    static void staticVoidMethod();

    // Types
    // Basic types
    Date dateMethod();
    DOMString stringMethod();
    ByteString byteStringMethod();
    USVString usvStringMethod();
    DOMTimeStamp readonlyDOMTimeStampMethod();
    boolean booleanMethod();
    byte byteMethod();
    double doubleMethod();
    float floatMethod();
    long longMethod();
    long long longLongMethod();
    octet octetMethod();
    short shortMethod();
    unsigned long unsignedLongMethod();
    unsigned long long unsignedLongLongMethod();
    unsigned short unsignedShortMethod();

    void voidMethodDateArg(Date dateArg);
    void voidMethodStringArg(DOMString stringArg);
    void voidMethodByteStringArg(ByteString stringArg);
    void voidMethodUSVStringArg(USVString usvStringArg);
    void voidMethodDOMTimeStampArg(DOMTimeStamp domTimeStampArg);
    void voidMethodBooleanArg(boolean booleanArg);
    void voidMethodByteArg(byte byteArg);
    void voidMethodDoubleArg(double doubleArg);
    void voidMethodFloatArg(float floatArg);
    void voidMethodLongArg(long longArg);
    void voidMethodLongLongArg(long long longLongArg);
    void voidMethodOctetArg(octet octetArg);
    void voidMethodShortArg(short shortArg);
    void voidMethodUnsignedLongArg(unsigned long unsignedLongArg);
    void voidMethodUnsignedLongLongArg(unsigned long long unsignedLongLongArg);
    void voidMethodUnsignedShortArg(unsigned short unsignedShortArg);
    // Interface types
    TestInterfaceEmpty testInterfaceEmptyMethod();
    void voidMethodTestInterfaceEmptyArg(TestInterfaceEmpty testInterfaceEmptyArg);
    void voidMethodLongArgTestInterfaceEmptyArg(long longArg, TestInterfaceEmpty testInterfaceEmptyArg);
    // Custom type conversions
    any anyMethod();
    void voidMethodEventTargetArg(EventTarget eventTargetArg);
    void voidMethodAnyArg(any anyArg);
    // DOM node types
    void voidMethodAttrArg(Attr attrArg);
    void voidMethodDocumentArg(Document documentArg);
    void voidMethodDocumentTypeArg(DocumentType documentTypeArg);
    void voidMethodElementArg(Element elementArg);
    void voidMethodNodeArg(Node nodeArg);
    // Typed arrays
    ArrayBuffer arrayBufferMethod();
    ArrayBufferView arrayBufferViewMethod();
    [RaisesException] ArrayBufferView arrayBufferViewMethodRaisesException();
    Float32Array float32ArrayMethod();
    Int32Array int32ArrayMethod();
    Uint8Array uint8ArrayMethod();
    void voidMethodArrayBufferArg(ArrayBuffer arrayBufferArg);
    void voidMethodArrayBufferOrNullArg(ArrayBuffer? arrayBufferArg);
    void voidMethodArrayBufferViewArg(ArrayBufferView arrayBufferViewArg);
    void voidMethodFlexibleArrayBufferViewArg([FlexibleArrayBufferView] ArrayBufferView arrayBufferViewArg);
    void voidMethodFlexibleArrayBufferViewTypedArg([FlexibleArrayBufferView] Float32Array typedArrayBufferViewArg);
    void voidMethodFloat32ArrayArg(Float32Array float32ArrayArg);
    void voidMethodInt32ArrayArg(Int32Array int32ArrayArg);
    void voidMethodUint8ArrayArg(Uint8Array uint8ArrayArg);
    void voidMethodAllowSharedArrayBufferViewArg([AllowShared] ArrayBufferView arrayBufferViewArg);
    void voidMethodAllowSharedUint8ArrayArg([AllowShared] Uint8Array uint8ArrayArg);
    // Sequences
    sequence<long> longSequenceMethod();
    sequence<DOMString> stringSequenceMethod();
    sequence<TestInterfaceEmpty> testInterfaceEmptySequenceMethod();
    void voidMethodSequenceLongArg(sequence<long> longSequenceArg);
    void voidMethodSequenceStringArg(sequence<DOMString> stringSequenceArg);
    void voidMethodSequenceTestInterfaceEmptyArg(sequence<TestInterfaceEmpty> testInterfaceEmptySequenceArg);
    void voidMethodSequenceSequenceDOMStringArg(sequence<sequence<DOMString>> stringSequenceSequenceArg);
    void voidMethodNullableSequenceLongArg(sequence<long>? longSequenceArg);
    // FrozenArrays
    FrozenArray<long> longFrozenArrayMethod();
    void voidMethodStringFrozenArrayMethod(FrozenArray<DOMString> stringFrozenArrayArg);
    void voidMethodTestInterfaceEmptyFrozenArrayMethod(FrozenArray<TestInterfaceEmpty> testInterfaceEmptyFrozenArrayArg);
    // Nullable types
    long? nullableLongMethod();
    DOMString? nullableStringMethod();
    TestInterface? nullableTestInterfaceMethod();
    sequence<long>? nullableLongSequenceMethod();
    // Union types
    (TestInterfaceGarbageCollected or DOMString) testInterfaceGarbageCollectedOrDOMStringMethod();
    (boolean or DOMString or unrestricted double) booleanOrDOMStringOrUnrestrictedDoubleMethod();
    (TestInterface or long) testInterfaceOrLongMethod();
    static (TestInterfaceGarbageCollected or DOMString) staticTestInterfaceGarbageCollectedOrDOMStringMethod();
    void voidMethodDoubleOrDOMStringArg((double or DOMString) arg);
    void voidMethodDoubleOrDOMStringOrNullArg((double or DOMString)? arg);
    void voidMethodDoubleOrNullOrDOMStringArg((double? or DOMString) arg);
    void voidMethodDOMStringOrArrayBufferOrArrayBufferViewArg((DOMString or ArrayBuffer or ArrayBufferView) arg);
    void voidMethodArrayBufferOrArrayBufferViewOrDictionaryArg((ArrayBuffer or ArrayBufferView or Dictionary) arg);
    // Unions with types that need extra includes/forward declarations in container types
    void voidMethodBooleanOrElementSequenceArg((BooleanType or sequence<Element>) arg);
    void voidMethodDoubleOrLongOrBooleanSequenceArg((double or sequence<(long or boolean)>) arg);
    void voidMethodElementSequenceOrByteStringDoubleOrStringRecord((sequence<Element> or record<ByteString, (double or DOMString)>) arg);
    // Array of Union types
    void voidMethodArrayOfDoubleOrDOMStringArg((double or DOMString)... arg);
    // Currently only used on interface type arguments
    void voidMethodTestInterfaceEmptyOrNullArg(TestInterfaceEmpty? nullableTestInterfaceEmptyArg);
    // Callback interface types
    void voidMethodTestCallbackInterfaceArg(TestCallbackInterface testCallbackInterfaceArg);
    void voidMethodOptionalTestCallbackInterfaceArg(optional TestCallbackInterface optionalTestCallbackInterfaceArg);
    void voidMethodTestCallbackInterfaceOrNullArg(TestCallbackInterface? testCallbackInterfaceArg);
    // Enumerations
    TestEnum testEnumMethod();
    void voidMethodTestEnumArg(TestEnum testEnumTypeArg);
    void voidMethodTestMultipleEnumArg(TestEnum testEnumTypeArg, TestEnum2 testEnumTypeArg2);
    // Exceptional types
    Dictionary dictionaryMethod();
    TestDictionary testDictionaryMethod();
    TestDictionary? nullableTestDictionaryMethod();
    static TestDictionary staticTestDictionaryMethod();
    static TestDictionary? staticNullableTestDictionaryMethod();
    void passPermissiveDictionaryMethod([PermissiveDictionaryConversion] optional TestDictionary arg);
    NodeFilter nodeFilterMethod();
    Promise<void> promiseMethod(long arg1, Dictionary arg2, DOMString arg3, DOMString... variadic);
    Promise promiseMethodWithoutExceptionState(Dictionary arg1);
    SerializedScriptValue serializedScriptValueMethod();
    XPathNSResolver xPathNSResolverMethod();
    void voidMethodDictionaryArg(Dictionary dictionaryArg);
    void voidMethodNodeFilterArg(NodeFilter nodeFilterArg);
    void voidMethodPromiseArg(Promise promiseArg);
    void voidMethodSerializedScriptValueArg(SerializedScriptValue serializedScriptValueArg);
    void voidMethodXPathNSResolverArg(XPathNSResolver xPathNSResolverArg);
    void voidMethodDictionarySequenceArg(sequence<Dictionary> dictionarySequenceArg);

    // Arguments
    void voidMethodStringArgLongArg(DOMString stringArg, long longArg);
    // Optional arguments
    void voidMethodOptionalStringArg(optional DOMString optionalStringArg);
    void voidMethodOptionalTestInterfaceEmptyArg(optional TestInterfaceEmpty optionalTestInterfaceEmptyArg);
    void voidMethodOptionalLongArg(optional long optionalLongArg);
    DOMString stringMethodOptionalLongArg(optional long optionalLongArg);
    TestInterfaceEmpty testInterfaceEmptyMethodOptionalLongArg(optional long optionalLongArg);
    long longMethodOptionalLongArg(optional long optionalLongArg);
    void voidMethodLongArgOptionalLongArg(long longArg, optional long optionalLongArg);
    void voidMethodLongArgOptionalLongArgOptionalLongArg(long longArg, optional long optionalLongArg1, optional long optionalLongArg2);
    void voidMethodLongArgOptionalTestInterfaceEmptyArg(long longArg, optional TestInterfaceEmpty optionalTestInterfaceEmpty);
    void voidMethodTestInterfaceEmptyArgOptionalLongArg(TestInterfaceEmpty optionalTestInterfaceEmpty, optional long longArg);
    // Optional arguments: exceptional case
    void voidMethodOptionalDictionaryArg(optional Dictionary optionalDictionaryArg);

    // Optional arguments with defaults
    void voidMethodDefaultByteStringArg(optional ByteString defaultByteStringArg = "foo");
    void voidMethodDefaultStringArg(optional DOMString defaultStringArg = "foo");
    void voidMethodDefaultIntegerArgs(optional long defaultLongArg = 10,
                                      optional long long defaultLongLongArg = -10,
                                      optional unsigned long defaultUnsignedArg = 0xFFFFFFFF);
    void voidMethodDefaultDoubleArg(optional double defaultDoubleArg = 0.5);
    void voidMethodDefaultTrueBooleanArg(optional boolean defaultBooleanArg = true);
    void voidMethodDefaultFalseBooleanArg(optional boolean defaultBooleanArg = false);
    void voidMethodDefaultNullableByteStringArg(optional ByteString? defaultStringArg = null);
    void voidMethodDefaultNullableStringArg(optional DOMString? defaultStringArg = null);
    void voidMethodDefaultNullableTestInterfaceArg(optional TestInterface? defaultTestInterfaceArg = null);
    void voidMethodDefaultDoubleOrStringArgs(optional (double or DOMString) defaultLongArg = 10.0,
                                             optional (double or DOMString?) defaultStringArg = "foo",
                                             optional (double or DOMString)? defaultNullArg = null);
    void voidMethodDefaultStringSequenceArg(optional sequence<DOMString> defaultStringSequenceArg = []);

    // Variadic operations
    void voidMethodVariadicStringArg(DOMString... variadicStringArgs);
    void voidMethodStringArgVariadicStringArg(DOMString stringArg, DOMString... variadicStringArgs);
    void voidMethodVariadicTestInterfaceEmptyArg(TestInterfaceEmpty... variadicTestInterfaceEmptyArgs);
    void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(TestInterfaceEmpty testInterfaceEmptyArg, TestInterfaceEmpty... variadicTestInterfaceEmptyArgs);
    void voidMethodVariadicTestInterfaceGarbageCollectedArg(TestInterfaceGarbageCollected... variadicTestInterfaceGarbageCollectedArg);

    // Overloaded methods
    void overloadedMethodA(long longArg);
    void overloadedMethodA(long longArg1, long longArg2);
    void overloadedMethodB(long longArg);
    void overloadedMethodB(DOMString stringArg, optional long longArg);
    void overloadedMethodC(long longArg);
    void overloadedMethodC(TestInterfaceEmpty testInterfaceEmptyArg);
    void overloadedMethodD(long longArg);
    void overloadedMethodD(sequence<long> longArraySequence);
    void overloadedMethodE(long longArg);
    void overloadedMethodE(TestInterfaceEmpty? testInterfaceEmptyOrNullArg);
    void overloadedMethodF(optional DOMString stringArg);
    void overloadedMethodF(double doubleArg);
    void overloadedMethodG(long longArg);
    void overloadedMethodG(optional TestInterfaceEmpty? testInterfaceEmptyOrNullArg = null);
    void overloadedMethodH(TestInterface testInterfaceArg);
    void overloadedMethodH(TestInterfaceEmpty testInterfaceEmptyArg);
    void overloadedMethodI(DOMString stringArg);
    void overloadedMethodI(double doubleArg);
    void overloadedMethodJ(DOMString stringArg);
    void overloadedMethodJ(TestDictionary testDictionaryArg);
    void overloadedMethodK(Function functionArg);
    void overloadedMethodK(DOMString stringArg);
    void overloadedMethodL(long longArg, any... restArgs);
    void overloadedMethodL(DOMString stringArg, any... restArgs);
    void overloadedMethodN(TestInterface testInterfaceArg);
    void overloadedMethodN(TestCallbackInterface testCallbackInterfaceArg);

    Promise promiseOverloadMethod();
    Promise promiseOverloadMethod(Window arg1, double arg2);
    Promise promiseOverloadMethod(Document arg1, double arg2);

    [PerWorldBindings] void overloadedPerWorldBindingsMethod();
    [PerWorldBindings] void overloadedPerWorldBindingsMethod(long longArg);

    static void overloadedStaticMethod(long longArg);
    static void overloadedStaticMethod(long longArg1, long longArg2);

    // Special operations
    [CallWith=ScriptState] getter any item(unsigned long index);
    [CallWith=ScriptState] getter object(DOMString name);
    [CallWith=ScriptState] setter DOMString setItem(unsigned long index, DOMString value);
    [CallWith=ScriptState] setter DOMString(DOMString name, DOMString value);
    [RaisesException, CallWith=ScriptState] deleter boolean(unsigned long index);
    [CallWith=ScriptState] deleter boolean(DOMString name);

    // Extended attributes for arguments
    // [Clamp]
    void voidMethodClampUnsignedShortArg([Clamp] unsigned short clampUnsignedShortArg);
    void voidMethodClampUnsignedLongArg([Clamp] unsigned long clampUnsignedLongArg);
    // [Default]
    void voidMethodDefaultUndefinedTestInterfaceEmptyArg([Default=Undefined] optional TestInterfaceEmpty defaultUndefinedTestInterfaceEmptyArg);
    void voidMethodDefaultUndefinedLongArg([Default=Undefined] optional long defaultUndefinedLongArg);
    void voidMethodDefaultUndefinedStringArg([Default=Undefined] optional DOMString defaultUndefinedStringArg);
    // [EnforceRange]
    void voidMethodEnforceRangeLongArg([EnforceRange] long enforceRangeLongArg);
    // [TreatNullAs]
    void voidMethodTreatNullAsEmptyStringStringArg([TreatNullAs=EmptyString] DOMString treatNullAsEmptyStringStringArg);
    void voidMethodTreatNullAsNullStringStringArg([TreatNullAs=NullString] DOMString treatNullAsNullStringStringArg);

    // Extended attributes for methods
    [LogActivity, LogAllWorlds] void activityLoggingAccessForAllWorldsMethod();
    [CallWith=ExecutionContext] void callWithExecutionContextVoidMethod();
    [CallWith=ScriptState] void callWithScriptStateVoidMethod();
    [CallWith=ScriptState] long callWithScriptStateLongMethod();
    [CallWith=(ScriptState,ExecutionContext)] void callWithScriptStateExecutionContextVoidMethod();
    [CallWith=(ScriptState,ScriptArguments)] void callWithScriptStateScriptArgumentsVoidMethod();
    [CallWith=(ScriptState,ScriptArguments)] void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(optional boolean optionalBooleanArg);
    [CallWith=CurrentWindow] void callWithCurrentWindow();
    [CallWith=(CurrentWindow,EnteredWindow)] void callWithCurrentWindowScriptWindow();
    [CallWith=ThisValue] void callWithThisValue();
    [CheckSecurity=ReturnValue] void checkSecurityForNodeVoidMethod();
    [Custom] void customVoidMethod();
    [Custom=CallPrologue] void customCallPrologueVoidMethod();
    [Custom=CallEpilogue] void customCallEpilogueVoidMethod();
    [DeprecateAs=voidMethod] void deprecatedVoidMethod();
    [ImplementedAs=implementedAsMethodName] void implementedAsVoidMethod();
    [MeasureAs=TestFeature] void measureAsVoidMethod();
    [Measure] void measureMethod();
    [Measure] void measureOverloadedMethod();
    [Measure] void measureOverloadedMethod(long arg);
    [DeprecateAs=TestFeatureA] void DeprecateAsOverloadedMethod();
    [DeprecateAs=TestFeatureB] void DeprecateAsOverloadedMethod(long arg);
    [DeprecateAs=TestFeature] void DeprecateAsSameValueOverloadedMethod();
    [DeprecateAs=TestFeature] void DeprecateAsSameValueOverloadedMethod(long arg);
    [MeasureAs=TestFeatureA] void measureAsOverloadedMethod();
    [MeasureAs=TestFeatureB] void measureAsOverloadedMethod(long arg);
    [MeasureAs=TestFeature] void measureAsSameValueOverloadedMethod();
    [MeasureAs=TestFeature] void measureAsSameValueOverloadedMethod(long arg);
    [DeprecateAs=TestFeatureA, MeasureAs=TestFeature] void deprecateAsMeasureAsSameValueOverloadedMethod();
    [DeprecateAs=TestFeatureB, MeasureAs=TestFeature] void deprecateAsMeasureAsSameValueOverloadedMethod(long arg);
    [DeprecateAs=TestFeature, MeasureAs=TestFeatureA] void deprecateAsSameValueMeasureAsOverloadedMethod();
    [DeprecateAs=TestFeature, MeasureAs=TestFeatureB] void deprecateAsSameValueMeasureAsOverloadedMethod(long arg);
    [DeprecateAs=TestFeatureA, MeasureAs=TestFeatureB] void deprecateAsSameValueMeasureAsSameValueOverloadedMethod();
    [DeprecateAs=TestFeatureA, MeasureAs=TestFeatureB] void deprecateAsSameValueMeasureAsSameValueOverloadedMethod(long arg);
    [NotEnumerable] void notEnumerableVoidMethod();
    [OriginTrialEnabled=FeatureName] void originTrialEnabledVoidMethod();
    [PerWorldBindings, OriginTrialEnabled=FeatureName] void perWorldBindingsOriginTrialEnabledVoidMethod();
    // TODO(iclelland): Re-enable origin trials on overloaded methods
    // (crbug.com/621641)
    // [OriginTrialEnabled=FeatureName] void originTrialEnabledOverloadedVoidMethod(DOMString stringArg);
    // [OriginTrialEnabled=FeatureName] void originTrialEnabledOverloadedVoidMethod(long longArg);
    // [OriginTrialEnabled=FeatureName1] void partiallyOriginTrialEnabledOverloadedVoidMethod(DOMString stringArg);
    // [OriginTrialEnabled=FeatureName2] void partiallyOriginTrialEnabledOverloadedVoidMethod(TestInterface testInterfaceArg);
    // void partiallyOriginTrialEnabledOverloadedVoidMethod(long longArg, DOMString stringArg);
    // [OriginTrialEnabled=FeatureName3] void partiallyOriginTrialEnabledOverloadedVoidMethod(long longArg, DOMString stringArg, TestInterface testInterfaceArg);
    [PerWorldBindings] void perWorldBindingsVoidMethod();
    [PerWorldBindings] void perWorldBindingsVoidMethodTestInterfaceEmptyArg(TestInterfaceEmpty testInterfaceEmptyArg);
    [PostMessage, RaisesException] void postMessage(SerializedScriptValue message, optional sequence<object> transfer);
    [LogActivity, LogAllWorlds, PerWorldBindings] void activityLoggingForAllWorldsPerWorldBindingsVoidMethod();
    [LogActivity, PerWorldBindings] void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod();
    [RaisesException] void raisesExceptionVoidMethod();
    [RaisesException] DOMString raisesExceptionStringMethod();
    [RaisesException] void raisesExceptionVoidMethodOptionalLongArg(optional long optionalLongArg);
    [RaisesException] void raisesExceptionVoidMethodTestCallbackInterfaceArg(TestCallbackInterface testCallbackInterfaceArg);
    [RaisesException] void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optional TestCallbackInterface optionalTestCallbackInterfaceArg);
    [RaisesException] TestInterfaceEmpty raisesExceptionTestInterfaceEmptyVoidMethod();
    [RaisesException] XPathNSResolver raisesExceptionXPathNSResolverVoidMethod();
    [CallWith=ExecutionContext, RaisesException] void callWithExecutionContextRaisesExceptionVoidMethodLongArg(long longArg);
    [RuntimeEnabled=FeatureName] void runtimeEnabledVoidMethod();
    [PerWorldBindings, RuntimeEnabled=FeatureName] void perWorldBindingsRuntimeEnabledVoidMethod();
    [RuntimeEnabled=FeatureName] void runtimeEnabledOverloadedVoidMethod(DOMString stringArg);
    [RuntimeEnabled=FeatureName] void runtimeEnabledOverloadedVoidMethod(long longArg);
    [RuntimeEnabled=FeatureName1] void partiallyRuntimeEnabledOverloadedVoidMethod(DOMString stringArg);
    [RuntimeEnabled=FeatureName2] void partiallyRuntimeEnabledOverloadedVoidMethod(TestInterface testInterfaceArg);
    void partiallyRuntimeEnabledOverloadedVoidMethod(long longArg, DOMString stringArg);
    [RuntimeEnabled=FeatureName3] void partiallyRuntimeEnabledOverloadedVoidMethod(long longArg, DOMString stringArg, TestInterface testInterfaceArg);
    [LegacyInterfaceTypeChecking] void legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyArg(TestInterfaceEmpty testInterfaceEmptyArg);
    [LegacyInterfaceTypeChecking] void legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyVariadicArg(TestInterfaceEmpty... testInterfaceEmptyArg);
    // Avoid redundant type checking
    void useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg(Node node1, optional Node node2);
    void useToImpl4ArgumentsCheckingIfPossibleWithNullableArg(Node node1, Node? node2);
    void useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg(Node node1, [Default=Undefined] optional Node node2);
    [Unforgeable] void unforgeableVoidMethod();
    void voidMethodTestInterfaceGarbageCollectedSequenceArg(sequence<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedSequenceArg);
    [NewObject] TestInterface newObjectTestInterfaceMethod();
    [NewObject] Promise<TestInterface> newObjectTestInterfacePromiseMethod();
    [RuntimeCallStatsCounter=RuntimeCallStatsCounterMethod] void RuntimeCallStatsCounterMethod();


    serializer DOMString serializerMethod();

    // Extended attributes on referenced interfaces
    // (not self; self-reference tests at interface themselves)
    attribute TestInterface testInterfaceAttribute; // [ImplementedAs]
    attribute TestInterfaceGarbageCollected testInterfaceGarbageCollectedAttribute; // [GarbageCollected]
    attribute TestInterfaceGarbageCollected? testInterfaceGarbageCollectedOrNullAttribute; // [GarbageCollected]

    maplike<[EnforceRange] long, DOMStringOrDouble>;
    [RuntimeEnabled=FeatureName, CallWith=ScriptState, RaisesException, ImplementedAs=myMaplikeClear] boolean clear();
};