// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

dictionary TestDictionary {
    boolean booleanMember;
    long longMember = 1;
    DOMString stringMember;
    TestInterface testInterfaceMember;
    double? doubleOrNullMember = null;
    double restrictedDoubleMember = 3.14;
    unrestricted double unrestrictedDoubleMember = 3.14;
    DOMString? stringOrNullMember = "default string value";
    TestInterface? testInterfaceOrNullMember;
    TestInterfaceGarbageCollected testInterfaceGarbageCollectedMember;
    TestInterfaceGarbageCollected? testInterfaceGarbageCollectedOrNullMember;
    sequence<DOMString> stringSequenceMember = [];
    sequence<[TreatNullAs=EmptyString] DOMString> treatNullAsStringSequenceMember = [];
    sequence<TestInterface> testInterfaceSequenceMember = [];
    sequence<TestObject> testObjectSequenceMember;
    sequence<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedSequenceMember = [];
    TestEnum enumMember = "foo";
    sequence<TestEnum> enumSequenceMember;
    Element? elementOrNullMember;
    object objectMember;
    object? objectOrNullMember;
    [ImplementedAs=createMember] boolean create;
    [DeprecateAs=CreateMember, ImplementedAs=createMember] boolean deprecatedCreateMember;
    // If done naively, collides with a C++ keyword.
    [ImplementedAs=isPublic] boolean public;
    (double or DOMString) doubleOrStringMember = 3.14;
    sequence<(double or DOMString)> doubleOrStringSequenceMember;
    (double or DOMString) otherDoubleOrStringMember = "default string value";
    (TestInterface2 or Uint8Array) testInterface2OrUint8ArrayMember;
    sequence<InternalDictionary> internalDictionarySequenceMember;
    Uint8Array uint8ArrayMember;
    EventTarget eventTargetMember;
    any anyMember = null;
    Dictionary dictionaryMember;
    [RuntimeEnabled=RuntimeFeature] boolean runtimeMember;
    record<ByteString, byte> recordMember;
    record<USVString, TestObject> garbageCollectedRecordMember;
    record<ByteString, (long or boolean)> unionInRecordMember;
    record<DOMString, any> anyInRecordMember;
    (Float or BooleanType) unionWithTypedefs;
    [Clamp] long applicableToTypeLongMember;
    [TreatNullAs=EmptyString] DOMString applicableToTypeStringMember;
};
