InspectorProtocolObjects.h source code [webkit/WebKitBuild/Debug/DerivedSources/ForwardingHeaders/JavaScriptCore/InspectorProtocolObjects.h]

1	/*
2	* Copyright (C) 2013 Google Inc. All rights reserved.
3	* Copyright (C) 2013-2016 Apple Inc. All rights reserved.
4	* Copyright (C) 2014 University of Washington. All rights reserved.
5	*
6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions
8	* are met:
9	* 1. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25	* THE POSSIBILITY OF SUCH DAMAGE.
26	*/
27
28	// DO NOT EDIT THIS FILE. It is automatically generated from CombinedDomains.json
29	// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
30
31	#pragma once
32
33	#include "InspectorProtocolTypes.h"
34	#include <wtf/Assertions.h>
35
36	namespace Inspector {
37
38
39
40	namespace Protocol {
41
42	// Versions.
43	namespace Audit {
44	static const unsigned VERSION = `2`;
45	} // Audit
46
47	namespace Recording {
48	static const unsigned VERSION = `1`;
49	} // Recording
50	// End of versions.
51
52
53	// Forward declarations.
54	namespace ApplicationCache {
55	class ApplicationCacheResource;
56	class ApplicationCache;
57	class FrameWithManifest;
58	} // ApplicationCache
59
60	#if ENABLE(RESOURCE_USAGE)
61	namespace CPUProfiler {
62	class ThreadInfo;
63	class Event;
64	} // CPUProfiler
65	#endif // ENABLE(RESOURCE_USAGE)
66
67	namespace CSS {
68	class CSSStyleId;
69	class CSSRuleId;
70	class PseudoIdMatches;
71	class InheritedStyleEntry;
72	class RuleMatch;
73	class CSSSelector;
74	class SelectorList;
75	class CSSStyleAttribute;
76	class CSSStyleSheetHeader;
77	class CSSStyleSheetBody;
78	class CSSRule;
79	class SourceRange;
80	class ShorthandEntry;
81	class CSSPropertyInfo;
82	class CSSComputedStyleProperty;
83	class CSSStyle;
84	class CSSProperty;
85	class CSSMedia;
86	enum class StyleSheetOrigin;
87	enum class PseudoId;
88	enum class CSSPropertyStatus;
89	} // CSS
90
91	namespace Canvas {
92	class ContextAttributes;
93	class Canvas;
94	enum class ContextType;
95	enum class ShaderType;
96	} // Canvas
97
98	namespace Console {
99	class Channel;
100	class ConsoleMessage;
101	class CallFrame;
102	class StackTrace;
103	enum class ChannelSource;
104	enum class ChannelLevel;
105	} // Console
106
107	namespace DOM {
108	class Node;
109	class DataBinding;
110	class EventListener;
111	class AccessibilityProperties;
112	class RGBAColor;
113	class HighlightConfig;
114	enum class PseudoType;
115	enum class ShadowRootType;
116	enum class CustomElementState;
117	enum class LiveRegionRelevant;
118	} // DOM
119
120	namespace DOMDebugger {
121	enum class DOMBreakpointType;
122	enum class EventBreakpointType;
123	} // DOMDebugger
124
125	namespace DOMStorage {
126	class StorageId;
127	} // DOMStorage
128
129	namespace Database {
130	class Database;
131	class Error;
132	} // Database
133
134	namespace Debugger {
135	class Location;
136	class BreakpointAction;
137	class BreakpointOptions;
138	class FunctionDetails;
139	class CallFrame;
140	class Scope;
141	class ProbeSample;
142	class AssertPauseReason;
143	class BreakpointPauseReason;
144	class CSPViolationPauseReason;
145	} // Debugger
146
147	namespace GenericTypes {
148	class SearchMatch;
149	} // GenericTypes
150
151	namespace Heap {
152	class GarbageCollection;
153	} // Heap
154
155	#if ENABLE(INDEXED_DATABASE)
156	namespace IndexedDB {
157	class DatabaseWithObjectStores;
158	class ObjectStore;
159	class ObjectStoreIndex;
160	class Key;
161	class KeyRange;
162	class DataEntry;
163	class KeyPath;
164	} // IndexedDB
165	#endif // ENABLE(INDEXED_DATABASE)
166
167	namespace LayerTree {
168	class IntRect;
169	class Layer;
170	class CompositingReasons;
171	} // LayerTree
172
173	#if ENABLE(RESOURCE_USAGE)
174	namespace Memory {
175	class Event;
176	class CategoryData;
177	} // Memory
178	#endif // ENABLE(RESOURCE_USAGE)
179
180	namespace Network {
181	class Headers;
182	class ResourceTiming;
183	class Request;
184	class Response;
185	class Metrics;
186	class WebSocketRequest;
187	class WebSocketResponse;
188	class WebSocketFrame;
189	class CachedResource;
190	class Initiator;
191	} // Network
192
193	namespace Page {
194	class Frame;
195	class FrameResource;
196	class FrameResourceTree;
197	class SearchResult;
198	class Cookie;
199	enum class Setting;
200	enum class ResourceType;
201	enum class CoordinateSystem;
202	enum class CookieSameSitePolicy;
203	enum class Appearance;
204	} // Page
205
206	namespace Recording {
207	class InitialState;
208	class Frame;
209	class Recording;
210	enum class Type;
211	enum class Initiator;
212	} // Recording
213
214	namespace Runtime {
215	class RemoteObject;
216	class ObjectPreview;
217	class PropertyPreview;
218	class EntryPreview;
219	class CollectionEntry;
220	class PropertyDescriptor;
221	class InternalPropertyDescriptor;
222	class CallArgument;
223	class ExecutionContextDescription;
224	class ErrorRange;
225	class StructureDescription;
226	class TypeSet;
227	class TypeDescription;
228	class TypeLocation;
229	class BasicBlock;
230	enum class SyntaxErrorType;
231	} // Runtime
232
233	namespace ScriptProfiler {
234	class Event;
235	class ExpressionLocation;
236	class StackFrame;
237	class StackTrace;
238	class Samples;
239	enum class EventType;
240	} // ScriptProfiler
241
242	namespace Security {
243	class Connection;
244	class Certificate;
245	class Security;
246	} // Security
247
248	namespace ServiceWorker {
249	class Configuration;
250	} // ServiceWorker
251
252	namespace Target {
253	class TargetInfo;
254	} // Target
255
256	namespace Timeline {
257	class TimelineEvent;
258	enum class EventType;
259	enum class Instrument;
260	} // Timeline
261	// End of forward declarations.
262
263
264	// Typedefs.
265	namespace CSS {
266	typedef String StyleSheetId;
267	} // CSS
268
269	namespace Canvas {
270	/ Unique canvas identifier. /
271	typedef String CanvasId;
272	/ Unique shader program identifier. /
273	typedef String ProgramId;
274	} // Canvas
275
276	namespace DOM {
277	/ Unique DOM node identifier. /
278	typedef int NodeId;
279	/ Unique event listener identifier. /
280	typedef int EventListenerId;
281	/ An array of quad vertices, x immediately followed by y for each point, points clock-wise. /
282	typedef JSON::ArrayOf<double> Quad;
283	} // DOM
284
285	namespace DOMStorage {
286	/ DOM Storage item. /
287	typedef JSON::ArrayOf<String> Item;
288	} // DOMStorage
289
290	namespace Database {
291	/ Unique identifier of Database object. /
292	typedef String DatabaseId;
293	} // Database
294
295	namespace Debugger {
296	/ Breakpoint identifier. /
297	typedef String BreakpointId;
298	/ Breakpoint action identifier. /
299	typedef int BreakpointActionIdentifier;
300	/ Unique script identifier. /
301	typedef String ScriptId;
302	/ Call frame identifier. /
303	typedef String CallFrameId;
304	} // Debugger
305
306	namespace Heap {
307	/ JavaScriptCore HeapSnapshot JSON data. /
308	typedef String HeapSnapshotData;
309	} // Heap
310
311	namespace LayerTree {
312	/ Unique RenderLayer identifier. /
313	typedef String LayerId;
314	/ Unique PseudoElement identifier. /
315	typedef String PseudoElementId;
316	} // LayerTree
317
318	namespace Network {
319	/ Unique loader identifier. /
320	typedef String LoaderId;
321	/ Unique frame identifier. /
322	typedef String FrameId;
323	/ Unique request identifier. /
324	typedef String RequestId;
325	/ Elapsed seconds since frontend connected. /
326	typedef double Timestamp;
327	/ Number of seconds since epoch. /
328	typedef double Walltime;
329	} // Network
330
331	namespace Runtime {
332	/ Unique object identifier. /
333	typedef String RemoteObjectId;
334	/ Id of an execution context. /
335	typedef int ExecutionContextId;
336	} // Runtime
337	// End of typedefs.
338
339	namespace InspectorHelpers {
340
341	JS_EXPORT_PRIVATE String getEnumConstantValue(int code);
342
343	template<typename T> String getEnumConstantValue(T enumValue)
344	{
345	return getEnumConstantValue(static_cast<int>(enumValue));
346	}
347
348	} // namespace InspectorHelpers
349
350	namespace ApplicationCache {
351	/ Detailed application cache resource information. /
352	class ApplicationCacheResource : public JSON::ObjectBase {
353	public:
354	enum {
355	NoFieldsSet = `0`,
356	UrlSet = `1` << `0`,
357	SizeSet = `1` << `1`,
358	TypeSet = `1` << `2`,
359	AllFieldsSet = (UrlSet \| SizeSet \| TypeSet)
360	};
361
362	template<int STATE>
363	class Builder {
364	private:
365	RefPtr<JSON::Object> m_result;
366
367	template<int STEP> Builder<STATE \| STEP>& castState()
368	{
369	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
370	}
371
372	Builder(Ref</ApplicationCacheResource/JSON::Object>&& object)
373	: m_result (WTFMove(object))
374	{
375	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
376	}
377	friend class ApplicationCacheResource;
378	public:
379
380	Builder<STATE \| UrlSet>& setUrl(const String& value)
381	{
382	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
383	m_result ->setString("url"_s, value);
384	return castState<UrlSet>();
385	}
386
387	Builder<STATE \| SizeSet>& setSize(int value)
388	{
389	COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
390	m_result ->setInteger("size"_s, value);
391	return castState<SizeSet>();
392	}
393
394	Builder<STATE \| TypeSet>& setType(const String& value)
395	{
396	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
397	m_result ->setString("type"_s, value);
398	return castState<TypeSet>();
399	}
400
401	Ref<ApplicationCacheResource> release()
402	{
403	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
404	COMPILE_ASSERT(sizeof(ApplicationCacheResource) == sizeof(JSON::Object), cannot_cast);
405
406	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
407	auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCacheResource>*>(&jsonResult));
408	return result;
409	}
410	};
411
412	/*
413	* Synthetic constructor:
414	* Ref<ApplicationCacheResource> result = ApplicationCacheResource::create()
415	* .setUrl(...)
416	* .setSize(...)
417	* .setType(...)
418	* .release();
419	*/
420	static Builder<NoFieldsSet> create()
421	{
422	return Builder<NoFieldsSet>(JSON::Object::create());
423	}
424	};
425
426	/ Detailed application cache information. /
427	class ApplicationCache : public JSON::ObjectBase {
428	public:
429	enum {
430	NoFieldsSet = `0`,
431	ManifestURLSet = `1` << `0`,
432	SizeSet = `1` << `1`,
433	CreationTimeSet = `1` << `2`,
434	UpdateTimeSet = `1` << `3`,
435	ResourcesSet = `1` << `4`,
436	AllFieldsSet = (ManifestURLSet \| SizeSet \| CreationTimeSet \| UpdateTimeSet \| ResourcesSet)
437	};
438
439	template<int STATE>
440	class Builder {
441	private:
442	RefPtr<JSON::Object> m_result;
443
444	template<int STEP> Builder<STATE \| STEP>& castState()
445	{
446	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
447	}
448
449	Builder(Ref</ApplicationCache/JSON::Object>&& object)
450	: m_result (WTFMove(object))
451	{
452	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
453	}
454	friend class ApplicationCache;
455	public:
456
457	Builder<STATE \| ManifestURLSet>& setManifestURL(const String& value)
458	{
459	COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set);
460	m_result ->setString("manifestURL"_s, value);
461	return castState<ManifestURLSet>();
462	}
463
464	Builder<STATE \| SizeSet>& setSize(double value)
465	{
466	COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
467	m_result ->setDouble("size"_s, value);
468	return castState<SizeSet>();
469	}
470
471	Builder<STATE \| CreationTimeSet>& setCreationTime(double value)
472	{
473	COMPILE_ASSERT(!(STATE & CreationTimeSet), property_creationTime_already_set);
474	m_result ->setDouble("creationTime"_s, value);
475	return castState<CreationTimeSet>();
476	}
477
478	Builder<STATE \| UpdateTimeSet>& setUpdateTime(double value)
479	{
480	COMPILE_ASSERT(!(STATE & UpdateTimeSet), property_updateTime_already_set);
481	m_result ->setDouble("updateTime"_s, value);
482	return castState<UpdateTimeSet>();
483	}
484
485	Builder<STATE \| ResourcesSet>& setResources(RefPtr<JSON::ArrayOf<Inspector::Protocol::ApplicationCache::ApplicationCacheResource>> value)
486	{
487	COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set);
488	m_result ->setArray("resources"_s, value);
489	return castState<ResourcesSet>();
490	}
491
492	Ref<ApplicationCache> release()
493	{
494	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
495	COMPILE_ASSERT(sizeof(ApplicationCache) == sizeof(JSON::Object), cannot_cast);
496
497	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
498	auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCache>*>(&jsonResult));
499	return result;
500	}
501	};
502
503	/*
504	* Synthetic constructor:
505	* Ref<ApplicationCache> result = ApplicationCache::create()
506	* .setManifestURL(...)
507	* .setSize(...)
508	* .setCreationTime(...)
509	* .setUpdateTime(...)
510	* .setResources(...)
511	* .release();
512	*/
513	static Builder<NoFieldsSet> create()
514	{
515	return Builder<NoFieldsSet>(JSON::Object::create());
516	}
517	};
518
519	/ Frame identifier - manifest URL pair. /
520	class FrameWithManifest : public JSON::ObjectBase {
521	public:
522	enum {
523	NoFieldsSet = `0`,
524	FrameIdSet = `1` << `0`,
525	ManifestURLSet = `1` << `1`,
526	StatusSet = `1` << `2`,
527	AllFieldsSet = (FrameIdSet \| ManifestURLSet \| StatusSet)
528	};
529
530	template<int STATE>
531	class Builder {
532	private:
533	RefPtr<JSON::Object> m_result;
534
535	template<int STEP> Builder<STATE \| STEP>& castState()
536	{
537	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
538	}
539
540	Builder(Ref</FrameWithManifest/JSON::Object>&& object)
541	: m_result (WTFMove(object))
542	{
543	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
544	}
545	friend class FrameWithManifest;
546	public:
547
548	Builder<STATE \| FrameIdSet>& setFrameId(const String& value)
549	{
550	COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
551	m_result ->setString("frameId"_s, value);
552	return castState<FrameIdSet>();
553	}
554
555	Builder<STATE \| ManifestURLSet>& setManifestURL(const String& value)
556	{
557	COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set);
558	m_result ->setString("manifestURL"_s, value);
559	return castState<ManifestURLSet>();
560	}
561
562	Builder<STATE \| StatusSet>& setStatus(int value)
563	{
564	COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
565	m_result ->setInteger("status"_s, value);
566	return castState<StatusSet>();
567	}
568
569	Ref<FrameWithManifest> release()
570	{
571	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
572	COMPILE_ASSERT(sizeof(FrameWithManifest) == sizeof(JSON::Object), cannot_cast);
573
574	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
575	auto result = WTFMove(*reinterpret_cast<Ref<FrameWithManifest>*>(&jsonResult));
576	return result;
577	}
578	};
579
580	/*
581	* Synthetic constructor:
582	* Ref<FrameWithManifest> result = FrameWithManifest::create()
583	* .setFrameId(...)
584	* .setManifestURL(...)
585	* .setStatus(...)
586	* .release();
587	*/
588	static Builder<NoFieldsSet> create()
589	{
590	return Builder<NoFieldsSet>(JSON::Object::create());
591	}
592	};
593
594	} // ApplicationCache
595
596	#if ENABLE(RESOURCE_USAGE)
597	namespace CPUProfiler {
598	/ CPU usage for an individual thread. /
599	class ThreadInfo : public JSON::ObjectBase {
600	public:
601	// Named after property name 'type' while generating ThreadInfo.
602	enum class Type {
603	Main = `0`,
604	WebKit = `1`,
605	}; // enum class Type
606	enum {
607	NoFieldsSet = `0`,
608	NameSet = `1` << `0`,
609	UsageSet = `1` << `1`,
610	AllFieldsSet = (NameSet \| UsageSet)
611	};
612
613	template<int STATE>
614	class Builder {
615	private:
616	RefPtr<JSON::Object> m_result;
617
618	template<int STEP> Builder<STATE \| STEP>& castState()
619	{
620	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
621	}
622
623	Builder(Ref</ThreadInfo/JSON::Object>&& object)
624	: m_result (WTFMove(object))
625	{
626	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
627	}
628	friend class ThreadInfo;
629	public:
630
631	Builder<STATE \| NameSet>& setName(const String& value)
632	{
633	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
634	m_result ->setString("name"_s, value);
635	return castState<NameSet>();
636	}
637
638	Builder<STATE \| UsageSet>& setUsage(double value)
639	{
640	COMPILE_ASSERT(!(STATE & UsageSet), property_usage_already_set);
641	m_result ->setDouble("usage"_s, value);
642	return castState<UsageSet>();
643	}
644
645	Ref<ThreadInfo> release()
646	{
647	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
648	COMPILE_ASSERT(sizeof(ThreadInfo) == sizeof(JSON::Object), cannot_cast);
649
650	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
651	auto result = WTFMove(*reinterpret_cast<Ref<ThreadInfo>*>(&jsonResult));
652	return result;
653	}
654	};
655
656	/*
657	* Synthetic constructor:
658	* Ref<ThreadInfo> result = ThreadInfo::create()
659	* .setName(...)
660	* .setUsage(...)
661	* .release();
662	*/
663	static Builder<NoFieldsSet> create()
664	{
665	return Builder<NoFieldsSet>(JSON::Object::create());
666	}
667
668	void setType(Type value)
669	{
670	JSON::ObjectBase::setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
671	}
672
673	void setTargetId(const String& value)
674	{
675	JSON::ObjectBase::setString("targetId"_s, value);
676	}
677	};
678
679	class Event : public JSON::ObjectBase {
680	public:
681	enum {
682	NoFieldsSet = `0`,
683	TimestampSet = `1` << `0`,
684	UsageSet = `1` << `1`,
685	AllFieldsSet = (TimestampSet \| UsageSet)
686	};
687
688	template<int STATE>
689	class Builder {
690	private:
691	RefPtr<JSON::Object> m_result;
692
693	template<int STEP> Builder<STATE \| STEP>& castState()
694	{
695	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
696	}
697
698	Builder(Ref</Event/JSON::Object>&& object)
699	: m_result (WTFMove(object))
700	{
701	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
702	}
703	friend class Event;
704	public:
705
706	Builder<STATE \| TimestampSet>& setTimestamp(double value)
707	{
708	COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
709	m_result ->setDouble("timestamp"_s, value);
710	return castState<TimestampSet>();
711	}
712
713	Builder<STATE \| UsageSet>& setUsage(double value)
714	{
715	COMPILE_ASSERT(!(STATE & UsageSet), property_usage_already_set);
716	m_result ->setDouble("usage"_s, value);
717	return castState<UsageSet>();
718	}
719
720	Ref<Event> release()
721	{
722	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
723	COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
724
725	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
726	auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
727	return result;
728	}
729	};
730
731	/*
732	* Synthetic constructor:
733	* Ref<Event> result = Event::create()
734	* .setTimestamp(...)
735	* .setUsage(...)
736	* .release();
737	*/
738	static Builder<NoFieldsSet> create()
739	{
740	return Builder<NoFieldsSet>(JSON::Object::create());
741	}
742
743	void setThreads(RefPtr<JSON::ArrayOf<Inspector::Protocol::CPUProfiler::ThreadInfo>> value)
744	{
745	JSON::ObjectBase::setArray("threads"_s, WTFMove(value));
746	}
747	};
748
749	} // CPUProfiler
750	#endif // ENABLE(RESOURCE_USAGE)
751
752	namespace CSS {
753	/ This object identifies a CSS style in a unique way. /
754	class CSSStyleId : public JSON::ObjectBase {
755	public:
756	enum {
757	NoFieldsSet = `0`,
758	StyleSheetIdSet = `1` << `0`,
759	OrdinalSet = `1` << `1`,
760	AllFieldsSet = (StyleSheetIdSet \| OrdinalSet)
761	};
762
763	template<int STATE>
764	class Builder {
765	private:
766	RefPtr<JSON::Object> m_result;
767
768	template<int STEP> Builder<STATE \| STEP>& castState()
769	{
770	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
771	}
772
773	Builder(Ref</CSSStyleId/JSON::Object>&& object)
774	: m_result (WTFMove(object))
775	{
776	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
777	}
778	friend class CSSStyleId;
779	public:
780
781	Builder<STATE \| StyleSheetIdSet>& setStyleSheetId(const String& value)
782	{
783	COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
784	m_result ->setString("styleSheetId"_s, value);
785	return castState<StyleSheetIdSet>();
786	}
787
788	Builder<STATE \| OrdinalSet>& setOrdinal(int value)
789	{
790	COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set);
791	m_result ->setInteger("ordinal"_s, value);
792	return castState<OrdinalSet>();
793	}
794
795	Ref<CSSStyleId> release()
796	{
797	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
798	COMPILE_ASSERT(sizeof(CSSStyleId) == sizeof(JSON::Object), cannot_cast);
799
800	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
801	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleId>*>(&jsonResult));
802	return result;
803	}
804	};
805
806	/*
807	* Synthetic constructor:
808	* Ref<CSSStyleId> result = CSSStyleId::create()
809	* .setStyleSheetId(...)
810	* .setOrdinal(...)
811	* .release();
812	*/
813	static Builder<NoFieldsSet> create()
814	{
815	return Builder<NoFieldsSet>(JSON::Object::create());
816	}
817	};
818
819	/* Stylesheet type: "user" for user stylesheets, "user-agent" for user-agent stylesheets, "inspector" for stylesheets created by the inspector (i.e. those holding the "via inspector" rules), "regular" for regular stylesheets. */
820	enum class StyleSheetOrigin {
821	User = `2`,
822	UserAgent = `3`,
823	Inspector = `4`,
824	Regular = `5`,
825	}; // enum class StyleSheetOrigin
826	/ This object identifies a CSS rule in a unique way. /
827	class CSSRuleId : public JSON::ObjectBase {
828	public:
829	enum {
830	NoFieldsSet = `0`,
831	StyleSheetIdSet = `1` << `0`,
832	OrdinalSet = `1` << `1`,
833	AllFieldsSet = (StyleSheetIdSet \| OrdinalSet)
834	};
835
836	template<int STATE>
837	class Builder {
838	private:
839	RefPtr<JSON::Object> m_result;
840
841	template<int STEP> Builder<STATE \| STEP>& castState()
842	{
843	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
844	}
845
846	Builder(Ref</CSSRuleId/JSON::Object>&& object)
847	: m_result (WTFMove(object))
848	{
849	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
850	}
851	friend class CSSRuleId;
852	public:
853
854	Builder<STATE \| StyleSheetIdSet>& setStyleSheetId(const String& value)
855	{
856	COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
857	m_result ->setString("styleSheetId"_s, value);
858	return castState<StyleSheetIdSet>();
859	}
860
861	Builder<STATE \| OrdinalSet>& setOrdinal(int value)
862	{
863	COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set);
864	m_result ->setInteger("ordinal"_s, value);
865	return castState<OrdinalSet>();
866	}
867
868	Ref<CSSRuleId> release()
869	{
870	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
871	COMPILE_ASSERT(sizeof(CSSRuleId) == sizeof(JSON::Object), cannot_cast);
872
873	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
874	auto result = WTFMove(*reinterpret_cast<Ref<CSSRuleId>*>(&jsonResult));
875	return result;
876	}
877	};
878
879	/*
880	* Synthetic constructor:
881	* Ref<CSSRuleId> result = CSSRuleId::create()
882	* .setStyleSheetId(...)
883	* .setOrdinal(...)
884	* .release();
885	*/
886	static Builder<NoFieldsSet> create()
887	{
888	return Builder<NoFieldsSet>(JSON::Object::create());
889	}
890	};
891
892	/ Pseudo-style identifier (see <code>enum PseudoId</code> in <code>RenderStyleConstants.h</code>). /
893	enum class PseudoId {
894	FirstLine = `6`,
895	FirstLetter = `7`,
896	Marker = `8`,
897	Before = `9`,
898	After = `10`,
899	Selection = `11`,
900	Scrollbar = `12`,
901	ScrollbarThumb = `13`,
902	ScrollbarButton = `14`,
903	ScrollbarTrack = `15`,
904	ScrollbarTrackPiece = `16`,
905	ScrollbarCorner = `17`,
906	Resizer = `18`,
907	}; // enum class PseudoId
908	/ CSS rule collection for a single pseudo style. /
909	class PseudoIdMatches : public JSON::ObjectBase {
910	public:
911	enum {
912	NoFieldsSet = `0`,
913	PseudoIdSet = `1` << `0`,
914	MatchesSet = `1` << `1`,
915	AllFieldsSet = (PseudoIdSet \| MatchesSet)
916	};
917
918	template<int STATE>
919	class Builder {
920	private:
921	RefPtr<JSON::Object> m_result;
922
923	template<int STEP> Builder<STATE \| STEP>& castState()
924	{
925	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
926	}
927
928	Builder(Ref</PseudoIdMatches/JSON::Object>&& object)
929	: m_result (WTFMove(object))
930	{
931	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
932	}
933	friend class PseudoIdMatches;
934	public:
935
936	Builder<STATE \| PseudoIdSet>& setPseudoId(Inspector::Protocol::CSS::PseudoId value)
937	{
938	COMPILE_ASSERT(!(STATE & PseudoIdSet), property_pseudoId_already_set);
939	m_result ->setString("pseudoId"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
940	return castState<PseudoIdSet>();
941	}
942
943	Builder<STATE \| MatchesSet>& setMatches(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::RuleMatch>> value)
944	{
945	COMPILE_ASSERT(!(STATE & MatchesSet), property_matches_already_set);
946	m_result ->setArray("matches"_s, value);
947	return castState<MatchesSet>();
948	}
949
950	Ref<PseudoIdMatches> release()
951	{
952	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
953	COMPILE_ASSERT(sizeof(PseudoIdMatches) == sizeof(JSON::Object), cannot_cast);
954
955	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
956	auto result = WTFMove(*reinterpret_cast<Ref<PseudoIdMatches>*>(&jsonResult));
957	return result;
958	}
959	};
960
961	/*
962	* Synthetic constructor:
963	* Ref<PseudoIdMatches> result = PseudoIdMatches::create()
964	* .setPseudoId(...)
965	* .setMatches(...)
966	* .release();
967	*/
968	static Builder<NoFieldsSet> create()
969	{
970	return Builder<NoFieldsSet>(JSON::Object::create());
971	}
972	};
973
974	/ CSS rule collection for a single pseudo style. /
975	class InheritedStyleEntry : public JSON::ObjectBase {
976	public:
977	enum {
978	NoFieldsSet = `0`,
979	MatchedCSSRulesSet = `1` << `0`,
980	AllFieldsSet = (MatchedCSSRulesSet)
981	};
982
983	template<int STATE>
984	class Builder {
985	private:
986	RefPtr<JSON::Object> m_result;
987
988	template<int STEP> Builder<STATE \| STEP>& castState()
989	{
990	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
991	}
992
993	Builder(Ref</InheritedStyleEntry/JSON::Object>&& object)
994	: m_result (WTFMove(object))
995	{
996	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
997	}
998	friend class InheritedStyleEntry;
999	public:
1000
1001	Builder<STATE \| MatchedCSSRulesSet>& setMatchedCSSRules(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::RuleMatch>> value)
1002	{
1003	COMPILE_ASSERT(!(STATE & MatchedCSSRulesSet), property_matchedCSSRules_already_set);
1004	m_result ->setArray("matchedCSSRules"_s, value);
1005	return castState<MatchedCSSRulesSet>();
1006	}
1007
1008	Ref<InheritedStyleEntry> release()
1009	{
1010	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1011	COMPILE_ASSERT(sizeof(InheritedStyleEntry) == sizeof(JSON::Object), cannot_cast);
1012
1013	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1014	auto result = WTFMove(*reinterpret_cast<Ref<InheritedStyleEntry>*>(&jsonResult));
1015	return result;
1016	}
1017	};
1018
1019	/*
1020	* Synthetic constructor:
1021	* Ref<InheritedStyleEntry> result = InheritedStyleEntry::create()
1022	* .setMatchedCSSRules(...)
1023	* .release();
1024	*/
1025	static Builder<NoFieldsSet> create()
1026	{
1027	return Builder<NoFieldsSet>(JSON::Object::create());
1028	}
1029
1030	void setInlineStyle(RefPtr<Inspector::Protocol::CSS::CSSStyle> value)
1031	{
1032	JSON::ObjectBase::setObject("inlineStyle"_s, WTFMove(value));
1033	}
1034	};
1035
1036	/ Match data for a CSS rule. /
1037	class RuleMatch : public JSON::ObjectBase {
1038	public:
1039	enum {
1040	NoFieldsSet = `0`,
1041	RuleSet = `1` << `0`,
1042	MatchingSelectorsSet = `1` << `1`,
1043	AllFieldsSet = (RuleSet \| MatchingSelectorsSet)
1044	};
1045
1046	template<int STATE>
1047	class Builder {
1048	private:
1049	RefPtr<JSON::Object> m_result;
1050
1051	template<int STEP> Builder<STATE \| STEP>& castState()
1052	{
1053	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1054	}
1055
1056	Builder(Ref</RuleMatch/JSON::Object>&& object)
1057	: m_result (WTFMove(object))
1058	{
1059	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1060	}
1061	friend class RuleMatch;
1062	public:
1063
1064	Builder<STATE \| RuleSet>& setRule(RefPtr<Inspector::Protocol::CSS::CSSRule> value)
1065	{
1066	COMPILE_ASSERT(!(STATE & RuleSet), property_rule_already_set);
1067	m_result ->setObject("rule"_s, value);
1068	return castState<RuleSet>();
1069	}
1070
1071	Builder<STATE \| MatchingSelectorsSet>& setMatchingSelectors(RefPtr<JSON::ArrayOf<int>> value)
1072	{
1073	COMPILE_ASSERT(!(STATE & MatchingSelectorsSet), property_matchingSelectors_already_set);
1074	m_result ->setArray("matchingSelectors"_s, value);
1075	return castState<MatchingSelectorsSet>();
1076	}
1077
1078	Ref<RuleMatch> release()
1079	{
1080	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1081	COMPILE_ASSERT(sizeof(RuleMatch) == sizeof(JSON::Object), cannot_cast);
1082
1083	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1084	auto result = WTFMove(*reinterpret_cast<Ref<RuleMatch>*>(&jsonResult));
1085	return result;
1086	}
1087	};
1088
1089	/*
1090	* Synthetic constructor:
1091	* Ref<RuleMatch> result = RuleMatch::create()
1092	* .setRule(...)
1093	* .setMatchingSelectors(...)
1094	* .release();
1095	*/
1096	static Builder<NoFieldsSet> create()
1097	{
1098	return Builder<NoFieldsSet>(JSON::Object::create());
1099	}
1100	};
1101
1102	/ CSS selector. /
1103	class CSSSelector : public JSON::ObjectBase {
1104	public:
1105	enum {
1106	NoFieldsSet = `0`,
1107	TextSet = `1` << `0`,
1108	AllFieldsSet = (TextSet)
1109	};
1110
1111	template<int STATE>
1112	class Builder {
1113	private:
1114	RefPtr<JSON::Object> m_result;
1115
1116	template<int STEP> Builder<STATE \| STEP>& castState()
1117	{
1118	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1119	}
1120
1121	Builder(Ref</CSSSelector/JSON::Object>&& object)
1122	: m_result (WTFMove(object))
1123	{
1124	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1125	}
1126	friend class CSSSelector;
1127	public:
1128
1129	Builder<STATE \| TextSet>& setText(const String& value)
1130	{
1131	COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
1132	m_result ->setString("text"_s, value);
1133	return castState<TextSet>();
1134	}
1135
1136	Ref<CSSSelector> release()
1137	{
1138	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1139	COMPILE_ASSERT(sizeof(CSSSelector) == sizeof(JSON::Object), cannot_cast);
1140
1141	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1142	auto result = WTFMove(*reinterpret_cast<Ref<CSSSelector>*>(&jsonResult));
1143	return result;
1144	}
1145	};
1146
1147	/*
1148	* Synthetic constructor:
1149	* Ref<CSSSelector> result = CSSSelector::create()
1150	* .setText(...)
1151	* .release();
1152	*/
1153	static Builder<NoFieldsSet> create()
1154	{
1155	return Builder<NoFieldsSet>(JSON::Object::create());
1156	}
1157
1158	void setSpecificity(RefPtr<JSON::ArrayOf<int>> value)
1159	{
1160	JSON::ObjectBase::setArray("specificity"_s, WTFMove(value));
1161	}
1162
1163	void setDynamic(bool value)
1164	{
1165	JSON::ObjectBase::setBoolean("dynamic"_s, value);
1166	}
1167	};
1168
1169	/ Selector list data. /
1170	class SelectorList : public JSON::ObjectBase {
1171	public:
1172	enum {
1173	NoFieldsSet = `0`,
1174	SelectorsSet = `1` << `0`,
1175	TextSet = `1` << `1`,
1176	AllFieldsSet = (SelectorsSet \| TextSet)
1177	};
1178
1179	template<int STATE>
1180	class Builder {
1181	private:
1182	RefPtr<JSON::Object> m_result;
1183
1184	template<int STEP> Builder<STATE \| STEP>& castState()
1185	{
1186	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1187	}
1188
1189	Builder(Ref</SelectorList/JSON::Object>&& object)
1190	: m_result (WTFMove(object))
1191	{
1192	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1193	}
1194	friend class SelectorList;
1195	public:
1196
1197	Builder<STATE \| SelectorsSet>& setSelectors(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::CSSSelector>> value)
1198	{
1199	COMPILE_ASSERT(!(STATE & SelectorsSet), property_selectors_already_set);
1200	m_result ->setArray("selectors"_s, value);
1201	return castState<SelectorsSet>();
1202	}
1203
1204	Builder<STATE \| TextSet>& setText(const String& value)
1205	{
1206	COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
1207	m_result ->setString("text"_s, value);
1208	return castState<TextSet>();
1209	}
1210
1211	Ref<SelectorList> release()
1212	{
1213	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1214	COMPILE_ASSERT(sizeof(SelectorList) == sizeof(JSON::Object), cannot_cast);
1215
1216	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1217	auto result = WTFMove(*reinterpret_cast<Ref<SelectorList>*>(&jsonResult));
1218	return result;
1219	}
1220	};
1221
1222	/*
1223	* Synthetic constructor:
1224	* Ref<SelectorList> result = SelectorList::create()
1225	* .setSelectors(...)
1226	* .setText(...)
1227	* .release();
1228	*/
1229	static Builder<NoFieldsSet> create()
1230	{
1231	return Builder<NoFieldsSet>(JSON::Object::create());
1232	}
1233
1234	void setRange(RefPtr<Inspector::Protocol::CSS::SourceRange> value)
1235	{
1236	JSON::ObjectBase::setObject("range"_s, WTFMove(value));
1237	}
1238	};
1239
1240	/ CSS style information for a DOM style attribute. /
1241	class CSSStyleAttribute : public JSON::ObjectBase {
1242	public:
1243	enum {
1244	NoFieldsSet = `0`,
1245	NameSet = `1` << `0`,
1246	StyleSet = `1` << `1`,
1247	AllFieldsSet = (NameSet \| StyleSet)
1248	};
1249
1250	template<int STATE>
1251	class Builder {
1252	private:
1253	RefPtr<JSON::Object> m_result;
1254
1255	template<int STEP> Builder<STATE \| STEP>& castState()
1256	{
1257	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1258	}
1259
1260	Builder(Ref</CSSStyleAttribute/JSON::Object>&& object)
1261	: m_result (WTFMove(object))
1262	{
1263	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1264	}
1265	friend class CSSStyleAttribute;
1266	public:
1267
1268	Builder<STATE \| NameSet>& setName(const String& value)
1269	{
1270	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1271	m_result ->setString("name"_s, value);
1272	return castState<NameSet>();
1273	}
1274
1275	Builder<STATE \| StyleSet>& setStyle(RefPtr<Inspector::Protocol::CSS::CSSStyle> value)
1276	{
1277	COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set);
1278	m_result ->setObject("style"_s, value);
1279	return castState<StyleSet>();
1280	}
1281
1282	Ref<CSSStyleAttribute> release()
1283	{
1284	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1285	COMPILE_ASSERT(sizeof(CSSStyleAttribute) == sizeof(JSON::Object), cannot_cast);
1286
1287	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1288	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleAttribute>*>(&jsonResult));
1289	return result;
1290	}
1291	};
1292
1293	/*
1294	* Synthetic constructor:
1295	* Ref<CSSStyleAttribute> result = CSSStyleAttribute::create()
1296	* .setName(...)
1297	* .setStyle(...)
1298	* .release();
1299	*/
1300	static Builder<NoFieldsSet> create()
1301	{
1302	return Builder<NoFieldsSet>(JSON::Object::create());
1303	}
1304	};
1305
1306	/ CSS stylesheet meta-information. /
1307	class CSSStyleSheetHeader : public JSON::ObjectBase {
1308	public:
1309	enum {
1310	NoFieldsSet = `0`,
1311	StyleSheetIdSet = `1` << `0`,
1312	FrameIdSet = `1` << `1`,
1313	SourceURLSet = `1` << `2`,
1314	OriginSet = `1` << `3`,
1315	TitleSet = `1` << `4`,
1316	DisabledSet = `1` << `5`,
1317	IsInlineSet = `1` << `6`,
1318	StartLineSet = `1` << `7`,
1319	StartColumnSet = `1` << `8`,
1320	AllFieldsSet = (StyleSheetIdSet \| FrameIdSet \| SourceURLSet \| OriginSet \| TitleSet \| DisabledSet \| IsInlineSet \| StartLineSet \| StartColumnSet)
1321	};
1322
1323	template<int STATE>
1324	class Builder {
1325	private:
1326	RefPtr<JSON::Object> m_result;
1327
1328	template<int STEP> Builder<STATE \| STEP>& castState()
1329	{
1330	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1331	}
1332
1333	Builder(Ref</CSSStyleSheetHeader/JSON::Object>&& object)
1334	: m_result (WTFMove(object))
1335	{
1336	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1337	}
1338	friend class CSSStyleSheetHeader;
1339	public:
1340
1341	Builder<STATE \| StyleSheetIdSet>& setStyleSheetId(const String& value)
1342	{
1343	COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1344	m_result ->setString("styleSheetId"_s, value);
1345	return castState<StyleSheetIdSet>();
1346	}
1347
1348	Builder<STATE \| FrameIdSet>& setFrameId(const String& value)
1349	{
1350	COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
1351	m_result ->setString("frameId"_s, value);
1352	return castState<FrameIdSet>();
1353	}
1354
1355	Builder<STATE \| SourceURLSet>& setSourceURL(const String& value)
1356	{
1357	COMPILE_ASSERT(!(STATE & SourceURLSet), property_sourceURL_already_set);
1358	m_result ->setString("sourceURL"_s, value);
1359	return castState<SourceURLSet>();
1360	}
1361
1362	Builder<STATE \| OriginSet>& setOrigin(Inspector::Protocol::CSS::StyleSheetOrigin value)
1363	{
1364	COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set);
1365	m_result ->setString("origin"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
1366	return castState<OriginSet>();
1367	}
1368
1369	Builder<STATE \| TitleSet>& setTitle(const String& value)
1370	{
1371	COMPILE_ASSERT(!(STATE & TitleSet), property_title_already_set);
1372	m_result ->setString("title"_s, value);
1373	return castState<TitleSet>();
1374	}
1375
1376	Builder<STATE \| DisabledSet>& setDisabled(bool value)
1377	{
1378	COMPILE_ASSERT(!(STATE & DisabledSet), property_disabled_already_set);
1379	m_result ->setBoolean("disabled"_s, value);
1380	return castState<DisabledSet>();
1381	}
1382
1383	Builder<STATE \| IsInlineSet>& setIsInline(bool value)
1384	{
1385	COMPILE_ASSERT(!(STATE & IsInlineSet), property_isInline_already_set);
1386	m_result ->setBoolean("isInline"_s, value);
1387	return castState<IsInlineSet>();
1388	}
1389
1390	Builder<STATE \| StartLineSet>& setStartLine(double value)
1391	{
1392	COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set);
1393	m_result ->setDouble("startLine"_s, value);
1394	return castState<StartLineSet>();
1395	}
1396
1397	Builder<STATE \| StartColumnSet>& setStartColumn(double value)
1398	{
1399	COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set);
1400	m_result ->setDouble("startColumn"_s, value);
1401	return castState<StartColumnSet>();
1402	}
1403
1404	Ref<CSSStyleSheetHeader> release()
1405	{
1406	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1407	COMPILE_ASSERT(sizeof(CSSStyleSheetHeader) == sizeof(JSON::Object), cannot_cast);
1408
1409	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1410	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetHeader>*>(&jsonResult));
1411	return result;
1412	}
1413	};
1414
1415	/*
1416	* Synthetic constructor:
1417	* Ref<CSSStyleSheetHeader> result = CSSStyleSheetHeader::create()
1418	* .setStyleSheetId(...)
1419	* .setFrameId(...)
1420	* .setSourceURL(...)
1421	* .setOrigin(...)
1422	* .setTitle(...)
1423	* .setDisabled(...)
1424	* .setIsInline(...)
1425	* .setStartLine(...)
1426	* .setStartColumn(...)
1427	* .release();
1428	*/
1429	static Builder<NoFieldsSet> create()
1430	{
1431	return Builder<NoFieldsSet>(JSON::Object::create());
1432	}
1433	};
1434
1435	/ CSS stylesheet contents. /
1436	class CSSStyleSheetBody : public JSON::ObjectBase {
1437	public:
1438	enum {
1439	NoFieldsSet = `0`,
1440	StyleSheetIdSet = `1` << `0`,
1441	RulesSet = `1` << `1`,
1442	AllFieldsSet = (StyleSheetIdSet \| RulesSet)
1443	};
1444
1445	template<int STATE>
1446	class Builder {
1447	private:
1448	RefPtr<JSON::Object> m_result;
1449
1450	template<int STEP> Builder<STATE \| STEP>& castState()
1451	{
1452	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1453	}
1454
1455	Builder(Ref</CSSStyleSheetBody/JSON::Object>&& object)
1456	: m_result (WTFMove(object))
1457	{
1458	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1459	}
1460	friend class CSSStyleSheetBody;
1461	public:
1462
1463	Builder<STATE \| StyleSheetIdSet>& setStyleSheetId(const String& value)
1464	{
1465	COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1466	m_result ->setString("styleSheetId"_s, value);
1467	return castState<StyleSheetIdSet>();
1468	}
1469
1470	Builder<STATE \| RulesSet>& setRules(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::CSSRule>> value)
1471	{
1472	COMPILE_ASSERT(!(STATE & RulesSet), property_rules_already_set);
1473	m_result ->setArray("rules"_s, value);
1474	return castState<RulesSet>();
1475	}
1476
1477	Ref<CSSStyleSheetBody> release()
1478	{
1479	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1480	COMPILE_ASSERT(sizeof(CSSStyleSheetBody) == sizeof(JSON::Object), cannot_cast);
1481
1482	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1483	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetBody>*>(&jsonResult));
1484	return result;
1485	}
1486	};
1487
1488	/*
1489	* Synthetic constructor:
1490	* Ref<CSSStyleSheetBody> result = CSSStyleSheetBody::create()
1491	* .setStyleSheetId(...)
1492	* .setRules(...)
1493	* .release();
1494	*/
1495	static Builder<NoFieldsSet> create()
1496	{
1497	return Builder<NoFieldsSet>(JSON::Object::create());
1498	}
1499
1500	void setText(const String& value)
1501	{
1502	JSON::ObjectBase::setString("text"_s, value);
1503	}
1504	};
1505
1506	/ CSS rule representation. /
1507	class CSSRule : public JSON::ObjectBase {
1508	public:
1509	enum {
1510	NoFieldsSet = `0`,
1511	SelectorListSet = `1` << `0`,
1512	SourceLineSet = `1` << `1`,
1513	OriginSet = `1` << `2`,
1514	StyleSet = `1` << `3`,
1515	AllFieldsSet = (SelectorListSet \| SourceLineSet \| OriginSet \| StyleSet)
1516	};
1517
1518	template<int STATE>
1519	class Builder {
1520	private:
1521	RefPtr<JSON::Object> m_result;
1522
1523	template<int STEP> Builder<STATE \| STEP>& castState()
1524	{
1525	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1526	}
1527
1528	Builder(Ref</CSSRule/JSON::Object>&& object)
1529	: m_result (WTFMove(object))
1530	{
1531	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1532	}
1533	friend class CSSRule;
1534	public:
1535
1536	Builder<STATE \| SelectorListSet>& setSelectorList(RefPtr<Inspector::Protocol::CSS::SelectorList> value)
1537	{
1538	COMPILE_ASSERT(!(STATE & SelectorListSet), property_selectorList_already_set);
1539	m_result ->setObject("selectorList"_s, value);
1540	return castState<SelectorListSet>();
1541	}
1542
1543	Builder<STATE \| SourceLineSet>& setSourceLine(int value)
1544	{
1545	COMPILE_ASSERT(!(STATE & SourceLineSet), property_sourceLine_already_set);
1546	m_result ->setInteger("sourceLine"_s, value);
1547	return castState<SourceLineSet>();
1548	}
1549
1550	Builder<STATE \| OriginSet>& setOrigin(Inspector::Protocol::CSS::StyleSheetOrigin value)
1551	{
1552	COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set);
1553	m_result ->setString("origin"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
1554	return castState<OriginSet>();
1555	}
1556
1557	Builder<STATE \| StyleSet>& setStyle(RefPtr<Inspector::Protocol::CSS::CSSStyle> value)
1558	{
1559	COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set);
1560	m_result ->setObject("style"_s, value);
1561	return castState<StyleSet>();
1562	}
1563
1564	Ref<CSSRule> release()
1565	{
1566	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1567	COMPILE_ASSERT(sizeof(CSSRule) == sizeof(JSON::Object), cannot_cast);
1568
1569	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1570	auto result = WTFMove(*reinterpret_cast<Ref<CSSRule>*>(&jsonResult));
1571	return result;
1572	}
1573	};
1574
1575	/*
1576	* Synthetic constructor:
1577	* Ref<CSSRule> result = CSSRule::create()
1578	* .setSelectorList(...)
1579	* .setSourceLine(...)
1580	* .setOrigin(...)
1581	* .setStyle(...)
1582	* .release();
1583	*/
1584	static Builder<NoFieldsSet> create()
1585	{
1586	return Builder<NoFieldsSet>(JSON::Object::create());
1587	}
1588
1589	void setRuleId(RefPtr<Inspector::Protocol::CSS::CSSRuleId> value)
1590	{
1591	JSON::ObjectBase::setObject("ruleId"_s, WTFMove(value));
1592	}
1593
1594	void setSourceURL(const String& value)
1595	{
1596	JSON::ObjectBase::setString("sourceURL"_s, value);
1597	}
1598
1599	void setMedia(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::CSSMedia>> value)
1600	{
1601	JSON::ObjectBase::setArray("media"_s, WTFMove(value));
1602	}
1603	};
1604
1605	/ Text range within a resource. /
1606	class SourceRange : public JSON::ObjectBase {
1607	public:
1608	enum {
1609	NoFieldsSet = `0`,
1610	StartLineSet = `1` << `0`,
1611	StartColumnSet = `1` << `1`,
1612	EndLineSet = `1` << `2`,
1613	EndColumnSet = `1` << `3`,
1614	AllFieldsSet = (StartLineSet \| StartColumnSet \| EndLineSet \| EndColumnSet)
1615	};
1616
1617	template<int STATE>
1618	class Builder {
1619	private:
1620	RefPtr<JSON::Object> m_result;
1621
1622	template<int STEP> Builder<STATE \| STEP>& castState()
1623	{
1624	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1625	}
1626
1627	Builder(Ref</SourceRange/JSON::Object>&& object)
1628	: m_result (WTFMove(object))
1629	{
1630	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1631	}
1632	friend class SourceRange;
1633	public:
1634
1635	Builder<STATE \| StartLineSet>& setStartLine(int value)
1636	{
1637	COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set);
1638	m_result ->setInteger("startLine"_s, value);
1639	return castState<StartLineSet>();
1640	}
1641
1642	Builder<STATE \| StartColumnSet>& setStartColumn(int value)
1643	{
1644	COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set);
1645	m_result ->setInteger("startColumn"_s, value);
1646	return castState<StartColumnSet>();
1647	}
1648
1649	Builder<STATE \| EndLineSet>& setEndLine(int value)
1650	{
1651	COMPILE_ASSERT(!(STATE & EndLineSet), property_endLine_already_set);
1652	m_result ->setInteger("endLine"_s, value);
1653	return castState<EndLineSet>();
1654	}
1655
1656	Builder<STATE \| EndColumnSet>& setEndColumn(int value)
1657	{
1658	COMPILE_ASSERT(!(STATE & EndColumnSet), property_endColumn_already_set);
1659	m_result ->setInteger("endColumn"_s, value);
1660	return castState<EndColumnSet>();
1661	}
1662
1663	Ref<SourceRange> release()
1664	{
1665	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1666	COMPILE_ASSERT(sizeof(SourceRange) == sizeof(JSON::Object), cannot_cast);
1667
1668	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1669	auto result = WTFMove(*reinterpret_cast<Ref<SourceRange>*>(&jsonResult));
1670	return result;
1671	}
1672	};
1673
1674	/*
1675	* Synthetic constructor:
1676	* Ref<SourceRange> result = SourceRange::create()
1677	* .setStartLine(...)
1678	* .setStartColumn(...)
1679	* .setEndLine(...)
1680	* .setEndColumn(...)
1681	* .release();
1682	*/
1683	static Builder<NoFieldsSet> create()
1684	{
1685	return Builder<NoFieldsSet>(JSON::Object::create());
1686	}
1687	};
1688
1689	class ShorthandEntry : public JSON::ObjectBase {
1690	public:
1691	enum {
1692	NoFieldsSet = `0`,
1693	NameSet = `1` << `0`,
1694	ValueSet = `1` << `1`,
1695	AllFieldsSet = (NameSet \| ValueSet)
1696	};
1697
1698	template<int STATE>
1699	class Builder {
1700	private:
1701	RefPtr<JSON::Object> m_result;
1702
1703	template<int STEP> Builder<STATE \| STEP>& castState()
1704	{
1705	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1706	}
1707
1708	Builder(Ref</ShorthandEntry/JSON::Object>&& object)
1709	: m_result (WTFMove(object))
1710	{
1711	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1712	}
1713	friend class ShorthandEntry;
1714	public:
1715
1716	Builder<STATE \| NameSet>& setName(const String& value)
1717	{
1718	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1719	m_result ->setString("name"_s, value);
1720	return castState<NameSet>();
1721	}
1722
1723	Builder<STATE \| ValueSet>& setValue(const String& value)
1724	{
1725	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
1726	m_result ->setString("value"_s, value);
1727	return castState<ValueSet>();
1728	}
1729
1730	Ref<ShorthandEntry> release()
1731	{
1732	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1733	COMPILE_ASSERT(sizeof(ShorthandEntry) == sizeof(JSON::Object), cannot_cast);
1734
1735	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1736	auto result = WTFMove(*reinterpret_cast<Ref<ShorthandEntry>*>(&jsonResult));
1737	return result;
1738	}
1739	};
1740
1741	/*
1742	* Synthetic constructor:
1743	* Ref<ShorthandEntry> result = ShorthandEntry::create()
1744	* .setName(...)
1745	* .setValue(...)
1746	* .release();
1747	*/
1748	static Builder<NoFieldsSet> create()
1749	{
1750	return Builder<NoFieldsSet>(JSON::Object::create());
1751	}
1752	};
1753
1754	class CSSPropertyInfo : public JSON::ObjectBase {
1755	public:
1756	enum {
1757	NoFieldsSet = `0`,
1758	NameSet = `1` << `0`,
1759	AllFieldsSet = (NameSet)
1760	};
1761
1762	template<int STATE>
1763	class Builder {
1764	private:
1765	RefPtr<JSON::Object> m_result;
1766
1767	template<int STEP> Builder<STATE \| STEP>& castState()
1768	{
1769	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1770	}
1771
1772	Builder(Ref</CSSPropertyInfo/JSON::Object>&& object)
1773	: m_result (WTFMove(object))
1774	{
1775	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1776	}
1777	friend class CSSPropertyInfo;
1778	public:
1779
1780	Builder<STATE \| NameSet>& setName(const String& value)
1781	{
1782	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1783	m_result ->setString("name"_s, value);
1784	return castState<NameSet>();
1785	}
1786
1787	Ref<CSSPropertyInfo> release()
1788	{
1789	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1790	COMPILE_ASSERT(sizeof(CSSPropertyInfo) == sizeof(JSON::Object), cannot_cast);
1791
1792	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1793	auto result = WTFMove(*reinterpret_cast<Ref<CSSPropertyInfo>*>(&jsonResult));
1794	return result;
1795	}
1796	};
1797
1798	/*
1799	* Synthetic constructor:
1800	* Ref<CSSPropertyInfo> result = CSSPropertyInfo::create()
1801	* .setName(...)
1802	* .release();
1803	*/
1804	static Builder<NoFieldsSet> create()
1805	{
1806	return Builder<NoFieldsSet>(JSON::Object::create());
1807	}
1808
1809	void setAliases(RefPtr<JSON::ArrayOf<String>> value)
1810	{
1811	JSON::ObjectBase::setArray("aliases"_s, WTFMove(value));
1812	}
1813
1814	void setLonghands(RefPtr<JSON::ArrayOf<String>> value)
1815	{
1816	JSON::ObjectBase::setArray("longhands"_s, WTFMove(value));
1817	}
1818
1819	void setValues(RefPtr<JSON::ArrayOf<String>> value)
1820	{
1821	JSON::ObjectBase::setArray("values"_s, WTFMove(value));
1822	}
1823
1824	void setInherited(bool value)
1825	{
1826	JSON::ObjectBase::setBoolean("inherited"_s, value);
1827	}
1828	};
1829
1830	class CSSComputedStyleProperty : public JSON::ObjectBase {
1831	public:
1832	enum {
1833	NoFieldsSet = `0`,
1834	NameSet = `1` << `0`,
1835	ValueSet = `1` << `1`,
1836	AllFieldsSet = (NameSet \| ValueSet)
1837	};
1838
1839	template<int STATE>
1840	class Builder {
1841	private:
1842	RefPtr<JSON::Object> m_result;
1843
1844	template<int STEP> Builder<STATE \| STEP>& castState()
1845	{
1846	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1847	}
1848
1849	Builder(Ref</CSSComputedStyleProperty/JSON::Object>&& object)
1850	: m_result (WTFMove(object))
1851	{
1852	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1853	}
1854	friend class CSSComputedStyleProperty;
1855	public:
1856
1857	Builder<STATE \| NameSet>& setName(const String& value)
1858	{
1859	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1860	m_result ->setString("name"_s, value);
1861	return castState<NameSet>();
1862	}
1863
1864	Builder<STATE \| ValueSet>& setValue(const String& value)
1865	{
1866	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
1867	m_result ->setString("value"_s, value);
1868	return castState<ValueSet>();
1869	}
1870
1871	Ref<CSSComputedStyleProperty> release()
1872	{
1873	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1874	COMPILE_ASSERT(sizeof(CSSComputedStyleProperty) == sizeof(JSON::Object), cannot_cast);
1875
1876	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1877	auto result = WTFMove(*reinterpret_cast<Ref<CSSComputedStyleProperty>*>(&jsonResult));
1878	return result;
1879	}
1880	};
1881
1882	/*
1883	* Synthetic constructor:
1884	* Ref<CSSComputedStyleProperty> result = CSSComputedStyleProperty::create()
1885	* .setName(...)
1886	* .setValue(...)
1887	* .release();
1888	*/
1889	static Builder<NoFieldsSet> create()
1890	{
1891	return Builder<NoFieldsSet>(JSON::Object::create());
1892	}
1893	};
1894
1895	/ CSS style representation. /
1896	class CSSStyle : public JSON::ObjectBase {
1897	public:
1898	enum {
1899	NoFieldsSet = `0`,
1900	CssPropertiesSet = `1` << `0`,
1901	ShorthandEntriesSet = `1` << `1`,
1902	AllFieldsSet = (CssPropertiesSet \| ShorthandEntriesSet)
1903	};
1904
1905	template<int STATE>
1906	class Builder {
1907	private:
1908	RefPtr<JSON::Object> m_result;
1909
1910	template<int STEP> Builder<STATE \| STEP>& castState()
1911	{
1912	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1913	}
1914
1915	Builder(Ref</CSSStyle/JSON::Object>&& object)
1916	: m_result (WTFMove(object))
1917	{
1918	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1919	}
1920	friend class CSSStyle;
1921	public:
1922
1923	Builder<STATE \| CssPropertiesSet>& setCssProperties(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::CSSProperty>> value)
1924	{
1925	COMPILE_ASSERT(!(STATE & CssPropertiesSet), property_cssProperties_already_set);
1926	m_result ->setArray("cssProperties"_s, value);
1927	return castState<CssPropertiesSet>();
1928	}
1929
1930	Builder<STATE \| ShorthandEntriesSet>& setShorthandEntries(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::ShorthandEntry>> value)
1931	{
1932	COMPILE_ASSERT(!(STATE & ShorthandEntriesSet), property_shorthandEntries_already_set);
1933	m_result ->setArray("shorthandEntries"_s, value);
1934	return castState<ShorthandEntriesSet>();
1935	}
1936
1937	Ref<CSSStyle> release()
1938	{
1939	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1940	COMPILE_ASSERT(sizeof(CSSStyle) == sizeof(JSON::Object), cannot_cast);
1941
1942	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1943	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyle>*>(&jsonResult));
1944	return result;
1945	}
1946	};
1947
1948	/*
1949	* Synthetic constructor:
1950	* Ref<CSSStyle> result = CSSStyle::create()
1951	* .setCssProperties(...)
1952	* .setShorthandEntries(...)
1953	* .release();
1954	*/
1955	static Builder<NoFieldsSet> create()
1956	{
1957	return Builder<NoFieldsSet>(JSON::Object::create());
1958	}
1959
1960	void setStyleId(RefPtr<Inspector::Protocol::CSS::CSSStyleId> value)
1961	{
1962	JSON::ObjectBase::setObject("styleId"_s, WTFMove(value));
1963	}
1964
1965	void setCssText(const String& value)
1966	{
1967	JSON::ObjectBase::setString("cssText"_s, value);
1968	}
1969
1970	void setRange(RefPtr<Inspector::Protocol::CSS::SourceRange> value)
1971	{
1972	JSON::ObjectBase::setObject("range"_s, WTFMove(value));
1973	}
1974
1975	void setWidth(const String& value)
1976	{
1977	JSON::ObjectBase::setString("width"_s, value);
1978	}
1979
1980	void setHeight(const String& value)
1981	{
1982	JSON::ObjectBase::setString("height"_s, value);
1983	}
1984	};
1985
1986	/* The property status: "active" if the property is effective in the style, "inactive" if the property is overridden by a same-named property in this style later on, "disabled" if the property is disabled by the user, "style" (implied if absent) if the property is reported by the browser rather than by the CSS source parser. */
1987	enum class CSSPropertyStatus {
1988	Active = `19`,
1989	Inactive = `20`,
1990	Disabled = `21`,
1991	Style = `22`,
1992	}; // enum class CSSPropertyStatus
1993	/ CSS style effective visual dimensions and source offsets. /
1994	class CSSProperty : public JSON::Object {
1995	public:
1996	enum {
1997	NoFieldsSet = `0`,
1998	NameSet = `1` << `0`,
1999	ValueSet = `1` << `1`,
2000	AllFieldsSet = (NameSet \| ValueSet)
2001	};
2002
2003	template<int STATE>
2004	class Builder {
2005	private:
2006	RefPtr<JSON::Object> m_result;
2007
2008	template<int STEP> Builder<STATE \| STEP>& castState()
2009	{
2010	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2011	}
2012
2013	Builder(Ref</CSSProperty/JSON::Object>&& object)
2014	: m_result (WTFMove(object))
2015	{
2016	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2017	}
2018	friend class CSSProperty;
2019	public:
2020
2021	Builder<STATE \| NameSet>& setName(const String& value)
2022	{
2023	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2024	m_result ->setString("name"_s, value);
2025	return castState<NameSet>();
2026	}
2027
2028	Builder<STATE \| ValueSet>& setValue(const String& value)
2029	{
2030	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
2031	m_result ->setString("value"_s, value);
2032	return castState<ValueSet>();
2033	}
2034
2035	Ref<CSSProperty> release()
2036	{
2037	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2038	COMPILE_ASSERT(sizeof(CSSProperty) == sizeof(JSON::Object), cannot_cast);
2039
2040	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2041	auto result = WTFMove(*reinterpret_cast<Ref<CSSProperty>*>(&jsonResult));
2042	return result;
2043	}
2044	};
2045
2046	/*
2047	* Synthetic constructor:
2048	* Ref<CSSProperty> result = CSSProperty::create()
2049	* .setName(...)
2050	* .setValue(...)
2051	* .release();
2052	*/
2053	static Builder<NoFieldsSet> create()
2054	{
2055	return Builder<NoFieldsSet>(JSON::Object::create());
2056	}
2057
2058	void setPriority(const String& value)
2059	{
2060	JSON::ObjectBase::setString("priority"_s, value);
2061	}
2062
2063	void setImplicit(bool value)
2064	{
2065	JSON::ObjectBase::setBoolean("implicit"_s, value);
2066	}
2067
2068	void setText(const String& value)
2069	{
2070	JSON::ObjectBase::setString("text"_s, value);
2071	}
2072
2073	void setParsedOk(bool value)
2074	{
2075	JSON::ObjectBase::setBoolean("parsedOk"_s, value);
2076	}
2077
2078	void setStatus(Inspector::Protocol::CSS::CSSPropertyStatus value)
2079	{
2080	JSON::ObjectBase::setString("status"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2081	}
2082
2083	void setRange(RefPtr<Inspector::Protocol::CSS::SourceRange> value)
2084	{
2085	JSON::ObjectBase::setObject("range"_s, WTFMove(value));
2086	}
2087
2088	// Property names for type generated as open.
2089	JS_EXPORT_PRIVATE static const char* Name;
2090	JS_EXPORT_PRIVATE static const char* Value;
2091	JS_EXPORT_PRIVATE static const char* Priority;
2092	JS_EXPORT_PRIVATE static const char* Implicit;
2093	JS_EXPORT_PRIVATE static const char* Text;
2094	JS_EXPORT_PRIVATE static const char* ParsedOk;
2095	JS_EXPORT_PRIVATE static const char* Status;
2096	JS_EXPORT_PRIVATE static const char* Range;
2097	};
2098
2099	/ CSS media query descriptor. /
2100	class CSSMedia : public JSON::ObjectBase {
2101	public:
2102	// Named after property name 'source' while generating CSSMedia.
2103	enum class Source {
2104	MediaRule = `23`,
2105	ImportRule = `24`,
2106	LinkedSheet = `25`,
2107	InlineSheet = `26`,
2108	}; // enum class Source
2109	enum {
2110	NoFieldsSet = `0`,
2111	TextSet = `1` << `0`,
2112	SourceSet = `1` << `1`,
2113	AllFieldsSet = (TextSet \| SourceSet)
2114	};
2115
2116	template<int STATE>
2117	class Builder {
2118	private:
2119	RefPtr<JSON::Object> m_result;
2120
2121	template<int STEP> Builder<STATE \| STEP>& castState()
2122	{
2123	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2124	}
2125
2126	Builder(Ref</CSSMedia/JSON::Object>&& object)
2127	: m_result (WTFMove(object))
2128	{
2129	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2130	}
2131	friend class CSSMedia;
2132	public:
2133
2134	Builder<STATE \| TextSet>& setText(const String& value)
2135	{
2136	COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
2137	m_result ->setString("text"_s, value);
2138	return castState<TextSet>();
2139	}
2140
2141	Builder<STATE \| SourceSet>& setSource(Source value)
2142	{
2143	COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
2144	m_result ->setString("source"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2145	return castState<SourceSet>();
2146	}
2147
2148	Ref<CSSMedia> release()
2149	{
2150	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2151	COMPILE_ASSERT(sizeof(CSSMedia) == sizeof(JSON::Object), cannot_cast);
2152
2153	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2154	auto result = WTFMove(*reinterpret_cast<Ref<CSSMedia>*>(&jsonResult));
2155	return result;
2156	}
2157	};
2158
2159	/*
2160	* Synthetic constructor:
2161	* Ref<CSSMedia> result = CSSMedia::create()
2162	* .setText(...)
2163	* .setSource(...)
2164	* .release();
2165	*/
2166	static Builder<NoFieldsSet> create()
2167	{
2168	return Builder<NoFieldsSet>(JSON::Object::create());
2169	}
2170
2171	void setSourceURL(const String& value)
2172	{
2173	JSON::ObjectBase::setString("sourceURL"_s, value);
2174	}
2175
2176	void setSourceLine(int value)
2177	{
2178	JSON::ObjectBase::setInteger("sourceLine"_s, value);
2179	}
2180	};
2181
2182	} // CSS
2183
2184	namespace Canvas {
2185	/ The type of rendering context backing the canvas element. /
2186	enum class ContextType {
2187	Canvas2D = `27`,
2188	BitmapRenderer = `28`,
2189	WebGL = `29`,
2190	WebGL2 = `30`,
2191	WebGPU = `31`,
2192	}; // enum class ContextType
2193	/ Shader type. WebGL supports vertex and fragment shaders. /
2194	enum class ShaderType {
2195	Fragment = `32`,
2196	Vertex = `33`,
2197	}; // enum class ShaderType
2198	/ Drawing surface attributes. /
2199	class ContextAttributes : public JSON::ObjectBase {
2200	public:
2201	enum {
2202	NoFieldsSet = `0`,
2203	AllFieldsSet = `0`
2204	};
2205
2206	template<int STATE>
2207	class Builder {
2208	private:
2209	RefPtr<JSON::Object> m_result;
2210
2211	template<int STEP> Builder<STATE \| STEP>& castState()
2212	{
2213	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2214	}
2215
2216	Builder(Ref</ContextAttributes/JSON::Object>&& object)
2217	: m_result (WTFMove(object))
2218	{
2219	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2220	}
2221	friend class ContextAttributes;
2222	public:
2223
2224	Ref<ContextAttributes> release()
2225	{
2226	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2227	COMPILE_ASSERT(sizeof(ContextAttributes) == sizeof(JSON::Object), cannot_cast);
2228
2229	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2230	auto result = WTFMove(*reinterpret_cast<Ref<ContextAttributes>*>(&jsonResult));
2231	return result;
2232	}
2233	};
2234
2235	/*
2236	* Synthetic constructor:
2237	* Ref<ContextAttributes> result = ContextAttributes::create()
2238	* .release();
2239	*/
2240	static Builder<NoFieldsSet> create()
2241	{
2242	return Builder<NoFieldsSet>(JSON::Object::create());
2243	}
2244
2245	void setAlpha(bool value)
2246	{
2247	JSON::ObjectBase::setBoolean("alpha"_s, value);
2248	}
2249
2250	void setDepth(bool value)
2251	{
2252	JSON::ObjectBase::setBoolean("depth"_s, value);
2253	}
2254
2255	void setStencil(bool value)
2256	{
2257	JSON::ObjectBase::setBoolean("stencil"_s, value);
2258	}
2259
2260	void setAntialias(bool value)
2261	{
2262	JSON::ObjectBase::setBoolean("antialias"_s, value);
2263	}
2264
2265	void setPremultipliedAlpha(bool value)
2266	{
2267	JSON::ObjectBase::setBoolean("premultipliedAlpha"_s, value);
2268	}
2269
2270	void setPreserveDrawingBuffer(bool value)
2271	{
2272	JSON::ObjectBase::setBoolean("preserveDrawingBuffer"_s, value);
2273	}
2274
2275	void setFailIfMajorPerformanceCaveat(bool value)
2276	{
2277	JSON::ObjectBase::setBoolean("failIfMajorPerformanceCaveat"_s, value);
2278	}
2279	};
2280
2281	/ Information about a canvas for which a rendering context has been created. /
2282	class Canvas : public JSON::ObjectBase {
2283	public:
2284	enum {
2285	NoFieldsSet = `0`,
2286	CanvasIdSet = `1` << `0`,
2287	ContextTypeSet = `1` << `1`,
2288	AllFieldsSet = (CanvasIdSet \| ContextTypeSet)
2289	};
2290
2291	template<int STATE>
2292	class Builder {
2293	private:
2294	RefPtr<JSON::Object> m_result;
2295
2296	template<int STEP> Builder<STATE \| STEP>& castState()
2297	{
2298	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2299	}
2300
2301	Builder(Ref</Canvas/JSON::Object>&& object)
2302	: m_result (WTFMove(object))
2303	{
2304	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2305	}
2306	friend class Canvas;
2307	public:
2308
2309	Builder<STATE \| CanvasIdSet>& setCanvasId(const String& value)
2310	{
2311	COMPILE_ASSERT(!(STATE & CanvasIdSet), property_canvasId_already_set);
2312	m_result ->setString("canvasId"_s, value);
2313	return castState<CanvasIdSet>();
2314	}
2315
2316	Builder<STATE \| ContextTypeSet>& setContextType(Inspector::Protocol::Canvas::ContextType value)
2317	{
2318	COMPILE_ASSERT(!(STATE & ContextTypeSet), property_contextType_already_set);
2319	m_result ->setString("contextType"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2320	return castState<ContextTypeSet>();
2321	}
2322
2323	Ref<Canvas> release()
2324	{
2325	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2326	COMPILE_ASSERT(sizeof(Canvas) == sizeof(JSON::Object), cannot_cast);
2327
2328	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2329	auto result = WTFMove(*reinterpret_cast<Ref<Canvas>*>(&jsonResult));
2330	return result;
2331	}
2332	};
2333
2334	/*
2335	* Synthetic constructor:
2336	* Ref<Canvas> result = Canvas::create()
2337	* .setCanvasId(...)
2338	* .setContextType(...)
2339	* .release();
2340	*/
2341	static Builder<NoFieldsSet> create()
2342	{
2343	return Builder<NoFieldsSet>(JSON::Object::create());
2344	}
2345
2346	void setNodeId(int value)
2347	{
2348	JSON::ObjectBase::setInteger("nodeId"_s, value);
2349	}
2350
2351	void setCssCanvasName(const String& value)
2352	{
2353	JSON::ObjectBase::setString("cssCanvasName"_s, value);
2354	}
2355
2356	void setContextAttributes(RefPtr<Inspector::Protocol::Canvas::ContextAttributes> value)
2357	{
2358	JSON::ObjectBase::setObject("contextAttributes"_s, WTFMove(value));
2359	}
2360
2361	void setMemoryCost(double value)
2362	{
2363	JSON::ObjectBase::setDouble("memoryCost"_s, value);
2364	}
2365
2366	void setBacktrace(RefPtr<JSON::ArrayOf<Inspector::Protocol::Console::CallFrame>> value)
2367	{
2368	JSON::ObjectBase::setArray("backtrace"_s, WTFMove(value));
2369	}
2370	};
2371
2372	} // Canvas
2373
2374	namespace Console {
2375	/ Channels for different types of log messages. /
2376	enum class ChannelSource {
2377	XML = `34`,
2378	JavaScript = `35`,
2379	Network = `36`,
2380	ConsoleAPI = `37`,
2381	Storage = `38`,
2382	Appcache = `39`,
2383	Rendering = `40`,
2384	CSS = `41`,
2385	Security = `42`,
2386	ContentBlocker = `43`,
2387	Media = `44`,
2388	MediaSource = `45`,
2389	WebRTC = `46`,
2390	Other = `47`,
2391	}; // enum class ChannelSource
2392	/ Level of logging. /
2393	enum class ChannelLevel {
2394	Off = `48`,
2395	Basic = `49`,
2396	Verbose = `50`,
2397	}; // enum class ChannelLevel
2398	/ Logging channel. /
2399	class Channel : public JSON::ObjectBase {
2400	public:
2401	enum {
2402	NoFieldsSet = `0`,
2403	SourceSet = `1` << `0`,
2404	LevelSet = `1` << `1`,
2405	AllFieldsSet = (SourceSet \| LevelSet)
2406	};
2407
2408	template<int STATE>
2409	class Builder {
2410	private:
2411	RefPtr<JSON::Object> m_result;
2412
2413	template<int STEP> Builder<STATE \| STEP>& castState()
2414	{
2415	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2416	}
2417
2418	Builder(Ref</Channel/JSON::Object>&& object)
2419	: m_result (WTFMove(object))
2420	{
2421	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2422	}
2423	friend class Channel;
2424	public:
2425
2426	Builder<STATE \| SourceSet>& setSource(Inspector::Protocol::Console::ChannelSource value)
2427	{
2428	COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
2429	m_result ->setString("source"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2430	return castState<SourceSet>();
2431	}
2432
2433	Builder<STATE \| LevelSet>& setLevel(Inspector::Protocol::Console::ChannelLevel value)
2434	{
2435	COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set);
2436	m_result ->setString("level"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2437	return castState<LevelSet>();
2438	}
2439
2440	Ref<Channel> release()
2441	{
2442	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2443	COMPILE_ASSERT(sizeof(Channel) == sizeof(JSON::Object), cannot_cast);
2444
2445	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2446	auto result = WTFMove(*reinterpret_cast<Ref<Channel>*>(&jsonResult));
2447	return result;
2448	}
2449	};
2450
2451	/*
2452	* Synthetic constructor:
2453	* Ref<Channel> result = Channel::create()
2454	* .setSource(...)
2455	* .setLevel(...)
2456	* .release();
2457	*/
2458	static Builder<NoFieldsSet> create()
2459	{
2460	return Builder<NoFieldsSet>(JSON::Object::create());
2461	}
2462	};
2463
2464	/ Console message. /
2465	class ConsoleMessage : public JSON::ObjectBase {
2466	public:
2467	// Named after property name 'level' while generating ConsoleMessage.
2468	enum class Level {
2469	Log = `51`,
2470	Info = `52`,
2471	Warning = `53`,
2472	Error = `54`,
2473	Debug = `55`,
2474	}; // enum class Level
2475	// Named after property name 'type' while generating ConsoleMessage.
2476	enum class Type {
2477	Log = `51`,
2478	Dir = `56`,
2479	DirXML = `57`,
2480	Table = `58`,
2481	Trace = `59`,
2482	Clear = `60`,
2483	StartGroup = `61`,
2484	StartGroupCollapsed = `62`,
2485	EndGroup = `63`,
2486	Assert = `64`,
2487	Timing = `65`,
2488	Profile = `66`,
2489	ProfileEnd = `67`,
2490	Image = `68`,
2491	}; // enum class Type
2492	enum {
2493	NoFieldsSet = `0`,
2494	SourceSet = `1` << `0`,
2495	LevelSet = `1` << `1`,
2496	TextSet = `1` << `2`,
2497	AllFieldsSet = (SourceSet \| LevelSet \| TextSet)
2498	};
2499
2500	template<int STATE>
2501	class Builder {
2502	private:
2503	RefPtr<JSON::Object> m_result;
2504
2505	template<int STEP> Builder<STATE \| STEP>& castState()
2506	{
2507	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2508	}
2509
2510	Builder(Ref</ConsoleMessage/JSON::Object>&& object)
2511	: m_result (WTFMove(object))
2512	{
2513	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2514	}
2515	friend class ConsoleMessage;
2516	public:
2517
2518	Builder<STATE \| SourceSet>& setSource(Inspector::Protocol::Console::ChannelSource value)
2519	{
2520	COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
2521	m_result ->setString("source"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2522	return castState<SourceSet>();
2523	}
2524
2525	Builder<STATE \| LevelSet>& setLevel(Level value)
2526	{
2527	COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set);
2528	m_result ->setString("level"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2529	return castState<LevelSet>();
2530	}
2531
2532	Builder<STATE \| TextSet>& setText(const String& value)
2533	{
2534	COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
2535	m_result ->setString("text"_s, value);
2536	return castState<TextSet>();
2537	}
2538
2539	Ref<ConsoleMessage> release()
2540	{
2541	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2542	COMPILE_ASSERT(sizeof(ConsoleMessage) == sizeof(JSON::Object), cannot_cast);
2543
2544	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2545	auto result = WTFMove(*reinterpret_cast<Ref<ConsoleMessage>*>(&jsonResult));
2546	return result;
2547	}
2548	};
2549
2550	/*
2551	* Synthetic constructor:
2552	* Ref<ConsoleMessage> result = ConsoleMessage::create()
2553	* .setSource(...)
2554	* .setLevel(...)
2555	* .setText(...)
2556	* .release();
2557	*/
2558	static Builder<NoFieldsSet> create()
2559	{
2560	return Builder<NoFieldsSet>(JSON::Object::create());
2561	}
2562
2563	void setType(Type value)
2564	{
2565	JSON::ObjectBase::setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2566	}
2567
2568	void setUrl(const String& value)
2569	{
2570	JSON::ObjectBase::setString("url"_s, value);
2571	}
2572
2573	void setLine(int value)
2574	{
2575	JSON::ObjectBase::setInteger("line"_s, value);
2576	}
2577
2578	void setColumn(int value)
2579	{
2580	JSON::ObjectBase::setInteger("column"_s, value);
2581	}
2582
2583	void setRepeatCount(int value)
2584	{
2585	JSON::ObjectBase::setInteger("repeatCount"_s, value);
2586	}
2587
2588	void setParameters(RefPtr<JSON::ArrayOf<Inspector::Protocol::Runtime::RemoteObject>> value)
2589	{
2590	JSON::ObjectBase::setArray("parameters"_s, WTFMove(value));
2591	}
2592
2593	void setStackTrace(RefPtr<JSON::ArrayOf<Inspector::Protocol::Console::CallFrame>> value)
2594	{
2595	JSON::ObjectBase::setArray("stackTrace"_s, WTFMove(value));
2596	}
2597
2598	void setNetworkRequestId(const String& value)
2599	{
2600	JSON::ObjectBase::setString("networkRequestId"_s, value);
2601	}
2602	};
2603
2604	/ Stack entry for console errors and assertions. /
2605	class CallFrame : public JSON::ObjectBase {
2606	public:
2607	enum {
2608	NoFieldsSet = `0`,
2609	FunctionNameSet = `1` << `0`,
2610	UrlSet = `1` << `1`,
2611	ScriptIdSet = `1` << `2`,
2612	LineNumberSet = `1` << `3`,
2613	ColumnNumberSet = `1` << `4`,
2614	AllFieldsSet = (FunctionNameSet \| UrlSet \| ScriptIdSet \| LineNumberSet \| ColumnNumberSet)
2615	};
2616
2617	template<int STATE>
2618	class Builder {
2619	private:
2620	RefPtr<JSON::Object> m_result;
2621
2622	template<int STEP> Builder<STATE \| STEP>& castState()
2623	{
2624	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2625	}
2626
2627	Builder(Ref</CallFrame/JSON::Object>&& object)
2628	: m_result (WTFMove(object))
2629	{
2630	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2631	}
2632	friend class CallFrame;
2633	public:
2634
2635	Builder<STATE \| FunctionNameSet>& setFunctionName(const String& value)
2636	{
2637	COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set);
2638	m_result ->setString("functionName"_s, value);
2639	return castState<FunctionNameSet>();
2640	}
2641
2642	Builder<STATE \| UrlSet>& setUrl(const String& value)
2643	{
2644	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
2645	m_result ->setString("url"_s, value);
2646	return castState<UrlSet>();
2647	}
2648
2649	Builder<STATE \| ScriptIdSet>& setScriptId(const String& value)
2650	{
2651	COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set);
2652	m_result ->setString("scriptId"_s, value);
2653	return castState<ScriptIdSet>();
2654	}
2655
2656	Builder<STATE \| LineNumberSet>& setLineNumber(int value)
2657	{
2658	COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
2659	m_result ->setInteger("lineNumber"_s, value);
2660	return castState<LineNumberSet>();
2661	}
2662
2663	Builder<STATE \| ColumnNumberSet>& setColumnNumber(int value)
2664	{
2665	COMPILE_ASSERT(!(STATE & ColumnNumberSet), property_columnNumber_already_set);
2666	m_result ->setInteger("columnNumber"_s, value);
2667	return castState<ColumnNumberSet>();
2668	}
2669
2670	Ref<CallFrame> release()
2671	{
2672	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2673	COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast);
2674
2675	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2676	auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult));
2677	return result;
2678	}
2679	};
2680
2681	/*
2682	* Synthetic constructor:
2683	* Ref<CallFrame> result = CallFrame::create()
2684	* .setFunctionName(...)
2685	* .setUrl(...)
2686	* .setScriptId(...)
2687	* .setLineNumber(...)
2688	* .setColumnNumber(...)
2689	* .release();
2690	*/
2691	static Builder<NoFieldsSet> create()
2692	{
2693	return Builder<NoFieldsSet>(JSON::Object::create());
2694	}
2695	};
2696
2697	/ Call frames for async function calls, console assertions, and error messages. /
2698	class StackTrace : public JSON::ObjectBase {
2699	public:
2700	enum {
2701	NoFieldsSet = `0`,
2702	CallFramesSet = `1` << `0`,
2703	AllFieldsSet = (CallFramesSet)
2704	};
2705
2706	template<int STATE>
2707	class Builder {
2708	private:
2709	RefPtr<JSON::Object> m_result;
2710
2711	template<int STEP> Builder<STATE \| STEP>& castState()
2712	{
2713	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2714	}
2715
2716	Builder(Ref</StackTrace/JSON::Object>&& object)
2717	: m_result (WTFMove(object))
2718	{
2719	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2720	}
2721	friend class StackTrace;
2722	public:
2723
2724	Builder<STATE \| CallFramesSet>& setCallFrames(RefPtr<JSON::ArrayOf<Inspector::Protocol::Console::CallFrame>> value)
2725	{
2726	COMPILE_ASSERT(!(STATE & CallFramesSet), property_callFrames_already_set);
2727	m_result ->setArray("callFrames"_s, value);
2728	return castState<CallFramesSet>();
2729	}
2730
2731	Ref<StackTrace> release()
2732	{
2733	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2734	COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast);
2735
2736	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2737	auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult));
2738	return result;
2739	}
2740	};
2741
2742	/*
2743	* Synthetic constructor:
2744	* Ref<StackTrace> result = StackTrace::create()
2745	* .setCallFrames(...)
2746	* .release();
2747	*/
2748	static Builder<NoFieldsSet> create()
2749	{
2750	return Builder<NoFieldsSet>(JSON::Object::create());
2751	}
2752
2753	void setTopCallFrameIsBoundary(bool value)
2754	{
2755	JSON::ObjectBase::setBoolean("topCallFrameIsBoundary"_s, value);
2756	}
2757
2758	void setTruncated(bool value)
2759	{
2760	JSON::ObjectBase::setBoolean("truncated"_s, value);
2761	}
2762
2763	void setParentStackTrace(RefPtr<Inspector::Protocol::Console::StackTrace> value)
2764	{
2765	JSON::ObjectBase::setObject("parentStackTrace"_s, WTFMove(value));
2766	}
2767	};
2768
2769	} // Console
2770
2771	namespace DOM {
2772	/ Pseudo element type. /
2773	enum class PseudoType {
2774	Before = `9`,
2775	After = `10`,
2776	}; // enum class PseudoType
2777	/ Shadow root type. /
2778	enum class ShadowRootType {
2779	UserAgent = `3`,
2780	Open = `69`,
2781	Closed = `70`,
2782	}; // enum class ShadowRootType
2783	/ Custom element state. /
2784	enum class CustomElementState {
2785	Builtin = `71`,
2786	Custom = `72`,
2787	Waiting = `73`,
2788	Failed = `74`,
2789	}; // enum class CustomElementState
2790	/ Token values of @aria-relevant attribute. /
2791	enum class LiveRegionRelevant {
2792	Additions = `75`,
2793	Removals = `76`,
2794	Text = `77`,
2795	}; // enum class LiveRegionRelevant
2796	/ DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes. DOMNode is a base node mirror type. /
2797	class Node : public JSON::ObjectBase {
2798	public:
2799	enum {
2800	NoFieldsSet = `0`,
2801	NodeIdSet = `1` << `0`,
2802	NodeTypeSet = `1` << `1`,
2803	NodeNameSet = `1` << `2`,
2804	LocalNameSet = `1` << `3`,
2805	NodeValueSet = `1` << `4`,
2806	AllFieldsSet = (NodeIdSet \| NodeTypeSet \| NodeNameSet \| LocalNameSet \| NodeValueSet)
2807	};
2808
2809	template<int STATE>
2810	class Builder {
2811	private:
2812	RefPtr<JSON::Object> m_result;
2813
2814	template<int STEP> Builder<STATE \| STEP>& castState()
2815	{
2816	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2817	}
2818
2819	Builder(Ref</Node/JSON::Object>&& object)
2820	: m_result (WTFMove(object))
2821	{
2822	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2823	}
2824	friend class Node;
2825	public:
2826
2827	Builder<STATE \| NodeIdSet>& setNodeId(int value)
2828	{
2829	COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
2830	m_result ->setInteger("nodeId"_s, value);
2831	return castState<NodeIdSet>();
2832	}
2833
2834	Builder<STATE \| NodeTypeSet>& setNodeType(int value)
2835	{
2836	COMPILE_ASSERT(!(STATE & NodeTypeSet), property_nodeType_already_set);
2837	m_result ->setInteger("nodeType"_s, value);
2838	return castState<NodeTypeSet>();
2839	}
2840
2841	Builder<STATE \| NodeNameSet>& setNodeName(const String& value)
2842	{
2843	COMPILE_ASSERT(!(STATE & NodeNameSet), property_nodeName_already_set);
2844	m_result ->setString("nodeName"_s, value);
2845	return castState<NodeNameSet>();
2846	}
2847
2848	Builder<STATE \| LocalNameSet>& setLocalName(const String& value)
2849	{
2850	COMPILE_ASSERT(!(STATE & LocalNameSet), property_localName_already_set);
2851	m_result ->setString("localName"_s, value);
2852	return castState<LocalNameSet>();
2853	}
2854
2855	Builder<STATE \| NodeValueSet>& setNodeValue(const String& value)
2856	{
2857	COMPILE_ASSERT(!(STATE & NodeValueSet), property_nodeValue_already_set);
2858	m_result ->setString("nodeValue"_s, value);
2859	return castState<NodeValueSet>();
2860	}
2861
2862	Ref<Node> release()
2863	{
2864	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2865	COMPILE_ASSERT(sizeof(Node) == sizeof(JSON::Object), cannot_cast);
2866
2867	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2868	auto result = WTFMove(*reinterpret_cast<Ref<Node>*>(&jsonResult));
2869	return result;
2870	}
2871	};
2872
2873	/*
2874	* Synthetic constructor:
2875	* Ref<Node> result = Node::create()
2876	* .setNodeId(...)
2877	* .setNodeType(...)
2878	* .setNodeName(...)
2879	* .setLocalName(...)
2880	* .setNodeValue(...)
2881	* .release();
2882	*/
2883	static Builder<NoFieldsSet> create()
2884	{
2885	return Builder<NoFieldsSet>(JSON::Object::create());
2886	}
2887
2888	void setFrameId(const String& value)
2889	{
2890	JSON::ObjectBase::setString("frameId"_s, value);
2891	}
2892
2893	void setChildNodeCount(int value)
2894	{
2895	JSON::ObjectBase::setInteger("childNodeCount"_s, value);
2896	}
2897
2898	void setChildren(RefPtr<JSON::ArrayOf<Inspector::Protocol::DOM::Node>> value)
2899	{
2900	JSON::ObjectBase::setArray("children"_s, WTFMove(value));
2901	}
2902
2903	void setAttributes(RefPtr<JSON::ArrayOf<String>> value)
2904	{
2905	JSON::ObjectBase::setArray("attributes"_s, WTFMove(value));
2906	}
2907
2908	void setDocumentURL(const String& value)
2909	{
2910	JSON::ObjectBase::setString("documentURL"_s, value);
2911	}
2912
2913	void setBaseURL(const String& value)
2914	{
2915	JSON::ObjectBase::setString("baseURL"_s, value);
2916	}
2917
2918	void setPublicId(const String& value)
2919	{
2920	JSON::ObjectBase::setString("publicId"_s, value);
2921	}
2922
2923	void setSystemId(const String& value)
2924	{
2925	JSON::ObjectBase::setString("systemId"_s, value);
2926	}
2927
2928	void setXmlVersion(const String& value)
2929	{
2930	JSON::ObjectBase::setString("xmlVersion"_s, value);
2931	}
2932
2933	void setName(const String& value)
2934	{
2935	JSON::ObjectBase::setString("name"_s, value);
2936	}
2937
2938	void setValue(const String& value)
2939	{
2940	JSON::ObjectBase::setString("value"_s, value);
2941	}
2942
2943	void setPseudoType(Inspector::Protocol::DOM::PseudoType value)
2944	{
2945	JSON::ObjectBase::setString("pseudoType"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2946	}
2947
2948	void setShadowRootType(Inspector::Protocol::DOM::ShadowRootType value)
2949	{
2950	JSON::ObjectBase::setString("shadowRootType"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2951	}
2952
2953	void setCustomElementState(Inspector::Protocol::DOM::CustomElementState value)
2954	{
2955	JSON::ObjectBase::setString("customElementState"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2956	}
2957
2958	void setContentDocument(RefPtr<Inspector::Protocol::DOM::Node> value)
2959	{
2960	JSON::ObjectBase::setObject("contentDocument"_s, WTFMove(value));
2961	}
2962
2963	void setShadowRoots(RefPtr<JSON::ArrayOf<Inspector::Protocol::DOM::Node>> value)
2964	{
2965	JSON::ObjectBase::setArray("shadowRoots"_s, WTFMove(value));
2966	}
2967
2968	void setTemplateContent(RefPtr<Inspector::Protocol::DOM::Node> value)
2969	{
2970	JSON::ObjectBase::setObject("templateContent"_s, WTFMove(value));
2971	}
2972
2973	void setPseudoElements(RefPtr<JSON::ArrayOf<Inspector::Protocol::DOM::Node>> value)
2974	{
2975	JSON::ObjectBase::setArray("pseudoElements"_s, WTFMove(value));
2976	}
2977
2978	void setContentSecurityPolicyHash(const String& value)
2979	{
2980	JSON::ObjectBase::setString("contentSecurityPolicyHash"_s, value);
2981	}
2982	};
2983
2984	/ Relationship between data that is associated with a node and the node itself. /
2985	class DataBinding : public JSON::ObjectBase {
2986	public:
2987	enum {
2988	NoFieldsSet = `0`,
2989	BindingSet = `1` << `0`,
2990	ValueSet = `1` << `1`,
2991	AllFieldsSet = (BindingSet \| ValueSet)
2992	};
2993
2994	template<int STATE>
2995	class Builder {
2996	private:
2997	RefPtr<JSON::Object> m_result;
2998
2999	template<int STEP> Builder<STATE \| STEP>& castState()
3000	{
3001	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3002	}
3003
3004	Builder(Ref</DataBinding/JSON::Object>&& object)
3005	: m_result (WTFMove(object))
3006	{
3007	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3008	}
3009	friend class DataBinding;
3010	public:
3011
3012	Builder<STATE \| BindingSet>& setBinding(const String& value)
3013	{
3014	COMPILE_ASSERT(!(STATE & BindingSet), property_binding_already_set);
3015	m_result ->setString("binding"_s, value);
3016	return castState<BindingSet>();
3017	}
3018
3019	Builder<STATE \| ValueSet>& setValue(const String& value)
3020	{
3021	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
3022	m_result ->setString("value"_s, value);
3023	return castState<ValueSet>();
3024	}
3025
3026	Ref<DataBinding> release()
3027	{
3028	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3029	COMPILE_ASSERT(sizeof(DataBinding) == sizeof(JSON::Object), cannot_cast);
3030
3031	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3032	auto result = WTFMove(*reinterpret_cast<Ref<DataBinding>*>(&jsonResult));
3033	return result;
3034	}
3035	};
3036
3037	/*
3038	* Synthetic constructor:
3039	* Ref<DataBinding> result = DataBinding::create()
3040	* .setBinding(...)
3041	* .setValue(...)
3042	* .release();
3043	*/
3044	static Builder<NoFieldsSet> create()
3045	{
3046	return Builder<NoFieldsSet>(JSON::Object::create());
3047	}
3048
3049	void setType(const String& value)
3050	{
3051	JSON::ObjectBase::setString("type"_s, value);
3052	}
3053	};
3054
3055	/ A structure holding event listener properties. /
3056	class EventListener : public JSON::ObjectBase {
3057	public:
3058	enum {
3059	NoFieldsSet = `0`,
3060	EventListenerIdSet = `1` << `0`,
3061	TypeSet = `1` << `1`,
3062	UseCaptureSet = `1` << `2`,
3063	IsAttributeSet = `1` << `3`,
3064	AllFieldsSet = (EventListenerIdSet \| TypeSet \| UseCaptureSet \| IsAttributeSet)
3065	};
3066
3067	template<int STATE>
3068	class Builder {
3069	private:
3070	RefPtr<JSON::Object> m_result;
3071
3072	template<int STEP> Builder<STATE \| STEP>& castState()
3073	{
3074	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3075	}
3076
3077	Builder(Ref</EventListener/JSON::Object>&& object)
3078	: m_result (WTFMove(object))
3079	{
3080	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3081	}
3082	friend class EventListener;
3083	public:
3084
3085	Builder<STATE \| EventListenerIdSet>& setEventListenerId(int value)
3086	{
3087	COMPILE_ASSERT(!(STATE & EventListenerIdSet), property_eventListenerId_already_set);
3088	m_result ->setInteger("eventListenerId"_s, value);
3089	return castState<EventListenerIdSet>();
3090	}
3091
3092	Builder<STATE \| TypeSet>& setType(const String& value)
3093	{
3094	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
3095	m_result ->setString("type"_s, value);
3096	return castState<TypeSet>();
3097	}
3098
3099	Builder<STATE \| UseCaptureSet>& setUseCapture(bool value)
3100	{
3101	COMPILE_ASSERT(!(STATE & UseCaptureSet), property_useCapture_already_set);
3102	m_result ->setBoolean("useCapture"_s, value);
3103	return castState<UseCaptureSet>();
3104	}
3105
3106	Builder<STATE \| IsAttributeSet>& setIsAttribute(bool value)
3107	{
3108	COMPILE_ASSERT(!(STATE & IsAttributeSet), property_isAttribute_already_set);
3109	m_result ->setBoolean("isAttribute"_s, value);
3110	return castState<IsAttributeSet>();
3111	}
3112
3113	Ref<EventListener> release()
3114	{
3115	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3116	COMPILE_ASSERT(sizeof(EventListener) == sizeof(JSON::Object), cannot_cast);
3117
3118	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3119	auto result = WTFMove(*reinterpret_cast<Ref<EventListener>*>(&jsonResult));
3120	return result;
3121	}
3122	};
3123
3124	/*
3125	* Synthetic constructor:
3126	* Ref<EventListener> result = EventListener::create()
3127	* .setEventListenerId(...)
3128	* .setType(...)
3129	* .setUseCapture(...)
3130	* .setIsAttribute(...)
3131	* .release();
3132	*/
3133	static Builder<NoFieldsSet> create()
3134	{
3135	return Builder<NoFieldsSet>(JSON::Object::create());
3136	}
3137
3138	void setNodeId(int value)
3139	{
3140	JSON::ObjectBase::setInteger("nodeId"_s, value);
3141	}
3142
3143	void setOnWindow(bool value)
3144	{
3145	JSON::ObjectBase::setBoolean("onWindow"_s, value);
3146	}
3147
3148	void setLocation(RefPtr<Inspector::Protocol::Debugger::Location> value)
3149	{
3150	JSON::ObjectBase::setObject("location"_s, WTFMove(value));
3151	}
3152
3153	void setHandlerName(const String& value)
3154	{
3155	JSON::ObjectBase::setString("handlerName"_s, value);
3156	}
3157
3158	void setPassive(bool value)
3159	{
3160	JSON::ObjectBase::setBoolean("passive"_s, value);
3161	}
3162
3163	void setOnce(bool value)
3164	{
3165	JSON::ObjectBase::setBoolean("once"_s, value);
3166	}
3167
3168	void setDisabled(bool value)
3169	{
3170	JSON::ObjectBase::setBoolean("disabled"_s, value);
3171	}
3172
3173	void setHasBreakpoint(bool value)
3174	{
3175	JSON::ObjectBase::setBoolean("hasBreakpoint"_s, value);
3176	}
3177	};
3178
3179	/ A structure holding accessibility properties. /
3180	class AccessibilityProperties : public JSON::ObjectBase {
3181	public:
3182	// Named after property name 'checked' while generating AccessibilityProperties.
3183	enum class Checked {
3184	True = `78`,
3185	False = `79`,
3186	Mixed = `80`,
3187	}; // enum class Checked
3188	// Named after property name 'current' while generating AccessibilityProperties.
3189	enum class Current {
3190	True = `78`,
3191	False = `79`,
3192	Page = `81`,
3193	Step = `82`,
3194	Location = `83`,
3195	Date = `84`,
3196	Time = `85`,
3197	}; // enum class Current
3198	// Named after property name 'invalid' while generating AccessibilityProperties.
3199	enum class Invalid {
3200	True = `78`,
3201	False = `79`,
3202	Grammar = `86`,
3203	Spelling = `87`,
3204	}; // enum class Invalid
3205	// Named after property name 'liveRegionStatus' while generating AccessibilityProperties.
3206	enum class LiveRegionStatus {
3207	Assertive = `88`,
3208	Polite = `89`,
3209	Off = `48`,
3210	}; // enum class LiveRegionStatus
3211	enum {
3212	NoFieldsSet = `0`,
3213	ExistsSet = `1` << `0`,
3214	LabelSet = `1` << `1`,
3215	NodeIdSet = `1` << `2`,
3216	RoleSet = `1` << `3`,
3217	AllFieldsSet = (ExistsSet \| LabelSet \| NodeIdSet \| RoleSet)
3218	};
3219
3220	template<int STATE>
3221	class Builder {
3222	private:
3223	RefPtr<JSON::Object> m_result;
3224
3225	template<int STEP> Builder<STATE \| STEP>& castState()
3226	{
3227	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3228	}
3229
3230	Builder(Ref</AccessibilityProperties/JSON::Object>&& object)
3231	: m_result (WTFMove(object))
3232	{
3233	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3234	}
3235	friend class AccessibilityProperties;
3236	public:
3237
3238	Builder<STATE \| ExistsSet>& setExists(bool value)
3239	{
3240	COMPILE_ASSERT(!(STATE & ExistsSet), property_exists_already_set);
3241	m_result ->setBoolean("exists"_s, value);
3242	return castState<ExistsSet>();
3243	}
3244
3245	Builder<STATE \| LabelSet>& setLabel(const String& value)
3246	{
3247	COMPILE_ASSERT(!(STATE & LabelSet), property_label_already_set);
3248	m_result ->setString("label"_s, value);
3249	return castState<LabelSet>();
3250	}
3251
3252	Builder<STATE \| NodeIdSet>& setNodeId(int value)
3253	{
3254	COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
3255	m_result ->setInteger("nodeId"_s, value);
3256	return castState<NodeIdSet>();
3257	}
3258
3259	Builder<STATE \| RoleSet>& setRole(const String& value)
3260	{
3261	COMPILE_ASSERT(!(STATE & RoleSet), property_role_already_set);
3262	m_result ->setString("role"_s, value);
3263	return castState<RoleSet>();
3264	}
3265
3266	Ref<AccessibilityProperties> release()
3267	{
3268	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3269	COMPILE_ASSERT(sizeof(AccessibilityProperties) == sizeof(JSON::Object), cannot_cast);
3270
3271	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3272	auto result = WTFMove(*reinterpret_cast<Ref<AccessibilityProperties>*>(&jsonResult));
3273	return result;
3274	}
3275	};
3276
3277	/*
3278	* Synthetic constructor:
3279	* Ref<AccessibilityProperties> result = AccessibilityProperties::create()
3280	* .setExists(...)
3281	* .setLabel(...)
3282	* .setNodeId(...)
3283	* .setRole(...)
3284	* .release();
3285	*/
3286	static Builder<NoFieldsSet> create()
3287	{
3288	return Builder<NoFieldsSet>(JSON::Object::create());
3289	}
3290
3291	void setActiveDescendantNodeId(int value)
3292	{
3293	JSON::ObjectBase::setInteger("activeDescendantNodeId"_s, value);
3294	}
3295
3296	void setBusy(bool value)
3297	{
3298	JSON::ObjectBase::setBoolean("busy"_s, value);
3299	}
3300
3301	void setChecked(Checked value)
3302	{
3303	JSON::ObjectBase::setString("checked"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3304	}
3305
3306	void setChildNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3307	{
3308	JSON::ObjectBase::setArray("childNodeIds"_s, WTFMove(value));
3309	}
3310
3311	void setControlledNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3312	{
3313	JSON::ObjectBase::setArray("controlledNodeIds"_s, WTFMove(value));
3314	}
3315
3316	void setCurrent(Current value)
3317	{
3318	JSON::ObjectBase::setString("current"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3319	}
3320
3321	void setDisabled(bool value)
3322	{
3323	JSON::ObjectBase::setBoolean("disabled"_s, value);
3324	}
3325
3326	void setHeadingLevel(double value)
3327	{
3328	JSON::ObjectBase::setDouble("headingLevel"_s, value);
3329	}
3330
3331	void setHierarchyLevel(double value)
3332	{
3333	JSON::ObjectBase::setDouble("hierarchyLevel"_s, value);
3334	}
3335
3336	void setIsPopUpButton(bool value)
3337	{
3338	JSON::ObjectBase::setBoolean("isPopUpButton"_s, value);
3339	}
3340
3341	void setExpanded(bool value)
3342	{
3343	JSON::ObjectBase::setBoolean("expanded"_s, value);
3344	}
3345
3346	void setFlowedNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3347	{
3348	JSON::ObjectBase::setArray("flowedNodeIds"_s, WTFMove(value));
3349	}
3350
3351	void setFocused(bool value)
3352	{
3353	JSON::ObjectBase::setBoolean("focused"_s, value);
3354	}
3355
3356	void setIgnored(bool value)
3357	{
3358	JSON::ObjectBase::setBoolean("ignored"_s, value);
3359	}
3360
3361	void setIgnoredByDefault(bool value)
3362	{
3363	JSON::ObjectBase::setBoolean("ignoredByDefault"_s, value);
3364	}
3365
3366	void setInvalid(Invalid value)
3367	{
3368	JSON::ObjectBase::setString("invalid"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3369	}
3370
3371	void setHidden(bool value)
3372	{
3373	JSON::ObjectBase::setBoolean("hidden"_s, value);
3374	}
3375
3376	void setLiveRegionAtomic(bool value)
3377	{
3378	JSON::ObjectBase::setBoolean("liveRegionAtomic"_s, value);
3379	}
3380
3381	void setLiveRegionRelevant(RefPtr<JSON::ArrayOf<String>> value)
3382	{
3383	JSON::ObjectBase::setArray("liveRegionRelevant"_s, WTFMove(value));
3384	}
3385
3386	void setLiveRegionStatus(LiveRegionStatus value)
3387	{
3388	JSON::ObjectBase::setString("liveRegionStatus"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3389	}
3390
3391	void setMouseEventNodeId(int value)
3392	{
3393	JSON::ObjectBase::setInteger("mouseEventNodeId"_s, value);
3394	}
3395
3396	void setOwnedNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3397	{
3398	JSON::ObjectBase::setArray("ownedNodeIds"_s, WTFMove(value));
3399	}
3400
3401	void setParentNodeId(int value)
3402	{
3403	JSON::ObjectBase::setInteger("parentNodeId"_s, value);
3404	}
3405
3406	void setPressed(bool value)
3407	{
3408	JSON::ObjectBase::setBoolean("pressed"_s, value);
3409	}
3410
3411	void setReadonly(bool value)
3412	{
3413	JSON::ObjectBase::setBoolean("readonly"_s, value);
3414	}
3415
3416	void setRequired(bool value)
3417	{
3418	JSON::ObjectBase::setBoolean("required"_s, value);
3419	}
3420
3421	void setSelected(bool value)
3422	{
3423	JSON::ObjectBase::setBoolean("selected"_s, value);
3424	}
3425
3426	void setSelectedChildNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3427	{
3428	JSON::ObjectBase::setArray("selectedChildNodeIds"_s, WTFMove(value));
3429	}
3430	};
3431
3432	/ A structure holding an RGBA color. /
3433	class RGBAColor : public JSON::ObjectBase {
3434	public:
3435	enum {
3436	NoFieldsSet = `0`,
3437	RSet = `1` << `0`,
3438	GSet = `1` << `1`,
3439	BSet = `1` << `2`,
3440	AllFieldsSet = (RSet \| GSet \| BSet)
3441	};
3442
3443	template<int STATE>
3444	class Builder {
3445	private:
3446	RefPtr<JSON::Object> m_result;
3447
3448	template<int STEP> Builder<STATE \| STEP>& castState()
3449	{
3450	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3451	}
3452
3453	Builder(Ref</RGBAColor/JSON::Object>&& object)
3454	: m_result (WTFMove(object))
3455	{
3456	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3457	}
3458	friend class RGBAColor;
3459	public:
3460
3461	Builder<STATE \| RSet>& setR(int value)
3462	{
3463	COMPILE_ASSERT(!(STATE & RSet), property_r_already_set);
3464	m_result ->setInteger("r"_s, value);
3465	return castState<RSet>();
3466	}
3467
3468	Builder<STATE \| GSet>& setG(int value)
3469	{
3470	COMPILE_ASSERT(!(STATE & GSet), property_g_already_set);
3471	m_result ->setInteger("g"_s, value);
3472	return castState<GSet>();
3473	}
3474
3475	Builder<STATE \| BSet>& setB(int value)
3476	{
3477	COMPILE_ASSERT(!(STATE & BSet), property_b_already_set);
3478	m_result ->setInteger("b"_s, value);
3479	return castState<BSet>();
3480	}
3481
3482	Ref<RGBAColor> release()
3483	{
3484	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3485	COMPILE_ASSERT(sizeof(RGBAColor) == sizeof(JSON::Object), cannot_cast);
3486
3487	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3488	auto result = WTFMove(*reinterpret_cast<Ref<RGBAColor>*>(&jsonResult));
3489	return result;
3490	}
3491	};
3492
3493	/*
3494	* Synthetic constructor:
3495	* Ref<RGBAColor> result = RGBAColor::create()
3496	* .setR(...)
3497	* .setG(...)
3498	* .setB(...)
3499	* .release();
3500	*/
3501	static Builder<NoFieldsSet> create()
3502	{
3503	return Builder<NoFieldsSet>(JSON::Object::create());
3504	}
3505
3506	void setA(double value)
3507	{
3508	JSON::ObjectBase::setDouble("a"_s, value);
3509	}
3510	};
3511
3512	/ Configuration data for the highlighting of page elements. /
3513	class HighlightConfig : public JSON::ObjectBase {
3514	public:
3515	enum {
3516	NoFieldsSet = `0`,
3517	AllFieldsSet = `0`
3518	};
3519
3520	template<int STATE>
3521	class Builder {
3522	private:
3523	RefPtr<JSON::Object> m_result;
3524
3525	template<int STEP> Builder<STATE \| STEP>& castState()
3526	{
3527	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3528	}
3529
3530	Builder(Ref</HighlightConfig/JSON::Object>&& object)
3531	: m_result (WTFMove(object))
3532	{
3533	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3534	}
3535	friend class HighlightConfig;
3536	public:
3537
3538	Ref<HighlightConfig> release()
3539	{
3540	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3541	COMPILE_ASSERT(sizeof(HighlightConfig) == sizeof(JSON::Object), cannot_cast);
3542
3543	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3544	auto result = WTFMove(*reinterpret_cast<Ref<HighlightConfig>*>(&jsonResult));
3545	return result;
3546	}
3547	};
3548
3549	/*
3550	* Synthetic constructor:
3551	* Ref<HighlightConfig> result = HighlightConfig::create()
3552	* .release();
3553	*/
3554	static Builder<NoFieldsSet> create()
3555	{
3556	return Builder<NoFieldsSet>(JSON::Object::create());
3557	}
3558
3559	void setShowInfo(bool value)
3560	{
3561	JSON::ObjectBase::setBoolean("showInfo"_s, value);
3562	}
3563
3564	void setContentColor(RefPtr<Inspector::Protocol::DOM::RGBAColor> value)
3565	{
3566	JSON::ObjectBase::setObject("contentColor"_s, WTFMove(value));
3567	}
3568
3569	void setPaddingColor(RefPtr<Inspector::Protocol::DOM::RGBAColor> value)
3570	{
3571	JSON::ObjectBase::setObject("paddingColor"_s, WTFMove(value));
3572	}
3573
3574	void setBorderColor(RefPtr<Inspector::Protocol::DOM::RGBAColor> value)
3575	{
3576	JSON::ObjectBase::setObject("borderColor"_s, WTFMove(value));
3577	}
3578
3579	void setMarginColor(RefPtr<Inspector::Protocol::DOM::RGBAColor> value)
3580	{
3581	JSON::ObjectBase::setObject("marginColor"_s, WTFMove(value));
3582	}
3583	};
3584
3585	} // DOM
3586
3587	namespace DOMDebugger {
3588	/ DOM breakpoint type. /
3589	enum class DOMBreakpointType {
3590	SubtreeModified = `90`,
3591	AttributeModified = `91`,
3592	NodeRemoved = `92`,
3593	}; // enum class DOMBreakpointType
3594	/ Event breakpoint type. /
3595	enum class EventBreakpointType {
3596	AnimationFrame = `93`,
3597	Listener = `94`,
3598	Timer = `95`,
3599	}; // enum class EventBreakpointType
3600	} // DOMDebugger
3601
3602	namespace DOMStorage {
3603	/ DOM Storage identifier. /
3604	class StorageId : public JSON::ObjectBase {
3605	public:
3606	enum {
3607	NoFieldsSet = `0`,
3608	SecurityOriginSet = `1` << `0`,
3609	IsLocalStorageSet = `1` << `1`,
3610	AllFieldsSet = (SecurityOriginSet \| IsLocalStorageSet)
3611	};
3612
3613	template<int STATE>
3614	class Builder {
3615	private:
3616	RefPtr<JSON::Object> m_result;
3617
3618	template<int STEP> Builder<STATE \| STEP>& castState()
3619	{
3620	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3621	}
3622
3623	Builder(Ref</StorageId/JSON::Object>&& object)
3624	: m_result (WTFMove(object))
3625	{
3626	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3627	}
3628	friend class StorageId;
3629	public:
3630
3631	Builder<STATE \| SecurityOriginSet>& setSecurityOrigin(const String& value)
3632	{
3633	COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
3634	m_result ->setString("securityOrigin"_s, value);
3635	return castState<SecurityOriginSet>();
3636	}
3637
3638	Builder<STATE \| IsLocalStorageSet>& setIsLocalStorage(bool value)
3639	{
3640	COMPILE_ASSERT(!(STATE & IsLocalStorageSet), property_isLocalStorage_already_set);
3641	m_result ->setBoolean("isLocalStorage"_s, value);
3642	return castState<IsLocalStorageSet>();
3643	}
3644
3645	Ref<StorageId> release()
3646	{
3647	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3648	COMPILE_ASSERT(sizeof(StorageId) == sizeof(JSON::Object), cannot_cast);
3649
3650	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3651	auto result = WTFMove(*reinterpret_cast<Ref<StorageId>*>(&jsonResult));
3652	return result;
3653	}
3654	};
3655
3656	/*
3657	* Synthetic constructor:
3658	* Ref<StorageId> result = StorageId::create()
3659	* .setSecurityOrigin(...)
3660	* .setIsLocalStorage(...)
3661	* .release();
3662	*/
3663	static Builder<NoFieldsSet> create()
3664	{
3665	return Builder<NoFieldsSet>(JSON::Object::create());
3666	}
3667	};
3668
3669	} // DOMStorage
3670
3671	namespace Database {
3672	/ Database object. /
3673	class Database : public JSON::ObjectBase {
3674	public:
3675	enum {
3676	NoFieldsSet = `0`,
3677	IdSet = `1` << `0`,
3678	DomainSet = `1` << `1`,
3679	NameSet = `1` << `2`,
3680	VersionSet = `1` << `3`,
3681	AllFieldsSet = (IdSet \| DomainSet \| NameSet \| VersionSet)
3682	};
3683
3684	template<int STATE>
3685	class Builder {
3686	private:
3687	RefPtr<JSON::Object> m_result;
3688
3689	template<int STEP> Builder<STATE \| STEP>& castState()
3690	{
3691	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3692	}
3693
3694	Builder(Ref</Database/JSON::Object>&& object)
3695	: m_result (WTFMove(object))
3696	{
3697	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3698	}
3699	friend class Database;
3700	public:
3701
3702	Builder<STATE \| IdSet>& setId(const String& value)
3703	{
3704	COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
3705	m_result ->setString("id"_s, value);
3706	return castState<IdSet>();
3707	}
3708
3709	Builder<STATE \| DomainSet>& setDomain(const String& value)
3710	{
3711	COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set);
3712	m_result ->setString("domain"_s, value);
3713	return castState<DomainSet>();
3714	}
3715
3716	Builder<STATE \| NameSet>& setName(const String& value)
3717	{
3718	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
3719	m_result ->setString("name"_s, value);
3720	return castState<NameSet>();
3721	}
3722
3723	Builder<STATE \| VersionSet>& setVersion(const String& value)
3724	{
3725	COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
3726	m_result ->setString("version"_s, value);
3727	return castState<VersionSet>();
3728	}
3729
3730	Ref<Database> release()
3731	{
3732	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3733	COMPILE_ASSERT(sizeof(Database) == sizeof(JSON::Object), cannot_cast);
3734
3735	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3736	auto result = WTFMove(*reinterpret_cast<Ref<Database>*>(&jsonResult));
3737	return result;
3738	}
3739	};
3740
3741	/*
3742	* Synthetic constructor:
3743	* Ref<Database> result = Database::create()
3744	* .setId(...)
3745	* .setDomain(...)
3746	* .setName(...)
3747	* .setVersion(...)
3748	* .release();
3749	*/
3750	static Builder<NoFieldsSet> create()
3751	{
3752	return Builder<NoFieldsSet>(JSON::Object::create());
3753	}
3754	};
3755
3756	/ Database error. /
3757	class Error : public JSON::ObjectBase {
3758	public:
3759	enum {
3760	NoFieldsSet = `0`,
3761	MessageSet = `1` << `0`,
3762	CodeSet = `1` << `1`,
3763	AllFieldsSet = (MessageSet \| CodeSet)
3764	};
3765
3766	template<int STATE>
3767	class Builder {
3768	private:
3769	RefPtr<JSON::Object> m_result;
3770
3771	template<int STEP> Builder<STATE \| STEP>& castState()
3772	{
3773	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3774	}
3775
3776	Builder(Ref</Error/JSON::Object>&& object)
3777	: m_result (WTFMove(object))
3778	{
3779	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3780	}
3781	friend class Error;
3782	public:
3783
3784	Builder<STATE \| MessageSet>& setMessage(const String& value)
3785	{
3786	COMPILE_ASSERT(!(STATE & MessageSet), property_message_already_set);
3787	m_result ->setString("message"_s, value);
3788	return castState<MessageSet>();
3789	}
3790
3791	Builder<STATE \| CodeSet>& setCode(int value)
3792	{
3793	COMPILE_ASSERT(!(STATE & CodeSet), property_code_already_set);
3794	m_result ->setInteger("code"_s, value);
3795	return castState<CodeSet>();
3796	}
3797
3798	Ref<Error> release()
3799	{
3800	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3801	COMPILE_ASSERT(sizeof(Error) == sizeof(JSON::Object), cannot_cast);
3802
3803	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3804	auto result = WTFMove(*reinterpret_cast<Ref<Error>*>(&jsonResult));
3805	return result;
3806	}
3807	};
3808
3809	/*
3810	* Synthetic constructor:
3811	* Ref<Error> result = Error::create()
3812	* .setMessage(...)
3813	* .setCode(...)
3814	* .release();
3815	*/
3816	static Builder<NoFieldsSet> create()
3817	{
3818	return Builder<NoFieldsSet>(JSON::Object::create());
3819	}
3820	};
3821
3822	} // Database
3823
3824	namespace Debugger {
3825	/ Location in the source code. /
3826	class Location : public JSON::ObjectBase {
3827	public:
3828	enum {
3829	NoFieldsSet = `0`,
3830	ScriptIdSet = `1` << `0`,
3831	LineNumberSet = `1` << `1`,
3832	AllFieldsSet = (ScriptIdSet \| LineNumberSet)
3833	};
3834
3835	template<int STATE>
3836	class Builder {
3837	private:
3838	RefPtr<JSON::Object> m_result;
3839
3840	template<int STEP> Builder<STATE \| STEP>& castState()
3841	{
3842	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3843	}
3844
3845	Builder(Ref</Location/JSON::Object>&& object)
3846	: m_result (WTFMove(object))
3847	{
3848	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3849	}
3850	friend class Location;
3851	public:
3852
3853	Builder<STATE \| ScriptIdSet>& setScriptId(const String& value)
3854	{
3855	COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set);
3856	m_result ->setString("scriptId"_s, value);
3857	return castState<ScriptIdSet>();
3858	}
3859
3860	Builder<STATE \| LineNumberSet>& setLineNumber(int value)
3861	{
3862	COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
3863	m_result ->setInteger("lineNumber"_s, value);
3864	return castState<LineNumberSet>();
3865	}
3866
3867	Ref<Location> release()
3868	{
3869	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3870	COMPILE_ASSERT(sizeof(Location) == sizeof(JSON::Object), cannot_cast);
3871
3872	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3873	auto result = WTFMove(*reinterpret_cast<Ref<Location>*>(&jsonResult));
3874	return result;
3875	}
3876	};
3877
3878	/*
3879	* Synthetic constructor:
3880	* Ref<Location> result = Location::create()
3881	* .setScriptId(...)
3882	* .setLineNumber(...)
3883	* .release();
3884	*/
3885	static Builder<NoFieldsSet> create()
3886	{
3887	return Builder<NoFieldsSet>(JSON::Object::create());
3888	}
3889
3890	void setColumnNumber(int value)
3891	{
3892	JSON::ObjectBase::setInteger("columnNumber"_s, value);
3893	}
3894	};
3895
3896	/ Action to perform when a breakpoint is triggered. /
3897	class BreakpointAction : public JSON::ObjectBase {
3898	public:
3899	// Named after property name 'type' while generating BreakpointAction.
3900	enum class Type {
3901	Log = `51`,
3902	Evaluate = `96`,
3903	Sound = `97`,
3904	Probe = `98`,
3905	}; // enum class Type
3906	enum {
3907	NoFieldsSet = `0`,
3908	TypeSet = `1` << `0`,
3909	AllFieldsSet = (TypeSet)
3910	};
3911
3912	template<int STATE>
3913	class Builder {
3914	private:
3915	RefPtr<JSON::Object> m_result;
3916
3917	template<int STEP> Builder<STATE \| STEP>& castState()
3918	{
3919	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3920	}
3921
3922	Builder(Ref</BreakpointAction/JSON::Object>&& object)
3923	: m_result (WTFMove(object))
3924	{
3925	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3926	}
3927	friend class BreakpointAction;
3928	public:
3929
3930	Builder<STATE \| TypeSet>& setType(Type value)
3931	{
3932	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
3933	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3934	return castState<TypeSet>();
3935	}
3936
3937	Ref<BreakpointAction> release()
3938	{
3939	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3940	COMPILE_ASSERT(sizeof(BreakpointAction) == sizeof(JSON::Object), cannot_cast);
3941
3942	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3943	auto result = WTFMove(*reinterpret_cast<Ref<BreakpointAction>*>(&jsonResult));
3944	return result;
3945	}
3946	};
3947
3948	/*
3949	* Synthetic constructor:
3950	* Ref<BreakpointAction> result = BreakpointAction::create()
3951	* .setType(...)
3952	* .release();
3953	*/
3954	static Builder<NoFieldsSet> create()
3955	{
3956	return Builder<NoFieldsSet>(JSON::Object::create());
3957	}
3958
3959	void setData(const String& value)
3960	{
3961	JSON::ObjectBase::setString("data"_s, value);
3962	}
3963
3964	void setId(int value)
3965	{
3966	JSON::ObjectBase::setInteger("id"_s, value);
3967	}
3968	};
3969
3970	/ Extra options that modify breakpoint behavior. /
3971	class BreakpointOptions : public JSON::ObjectBase {
3972	public:
3973	enum {
3974	NoFieldsSet = `0`,
3975	AllFieldsSet = `0`
3976	};
3977
3978	template<int STATE>
3979	class Builder {
3980	private:
3981	RefPtr<JSON::Object> m_result;
3982
3983	template<int STEP> Builder<STATE \| STEP>& castState()
3984	{
3985	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3986	}
3987
3988	Builder(Ref</BreakpointOptions/JSON::Object>&& object)
3989	: m_result (WTFMove(object))
3990	{
3991	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3992	}
3993	friend class BreakpointOptions;
3994	public:
3995
3996	Ref<BreakpointOptions> release()
3997	{
3998	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3999	COMPILE_ASSERT(sizeof(BreakpointOptions) == sizeof(JSON::Object), cannot_cast);
4000
4001	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4002	auto result = WTFMove(*reinterpret_cast<Ref<BreakpointOptions>*>(&jsonResult));
4003	return result;
4004	}
4005	};
4006
4007	/*
4008	* Synthetic constructor:
4009	* Ref<BreakpointOptions> result = BreakpointOptions::create()
4010	* .release();
4011	*/
4012	static Builder<NoFieldsSet> create()
4013	{
4014	return Builder<NoFieldsSet>(JSON::Object::create());
4015	}
4016
4017	void setCondition(const String& value)
4018	{
4019	JSON::ObjectBase::setString("condition"_s, value);
4020	}
4021
4022	void setActions(RefPtr<JSON::ArrayOf<Inspector::Protocol::Debugger::BreakpointAction>> value)
4023	{
4024	JSON::ObjectBase::setArray("actions"_s, WTFMove(value));
4025	}
4026
4027	void setAutoContinue(bool value)
4028	{
4029	JSON::ObjectBase::setBoolean("autoContinue"_s, value);
4030	}
4031
4032	void setIgnoreCount(int value)
4033	{
4034	JSON::ObjectBase::setInteger("ignoreCount"_s, value);
4035	}
4036	};
4037
4038	/ Information about the function. /
4039	class FunctionDetails : public JSON::ObjectBase {
4040	public:
4041	enum {
4042	NoFieldsSet = `0`,
4043	LocationSet = `1` << `0`,
4044	AllFieldsSet = (LocationSet)
4045	};
4046
4047	template<int STATE>
4048	class Builder {
4049	private:
4050	RefPtr<JSON::Object> m_result;
4051
4052	template<int STEP> Builder<STATE \| STEP>& castState()
4053	{
4054	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4055	}
4056
4057	Builder(Ref</FunctionDetails/JSON::Object>&& object)
4058	: m_result (WTFMove(object))
4059	{
4060	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4061	}
4062	friend class FunctionDetails;
4063	public:
4064
4065	Builder<STATE \| LocationSet>& setLocation(RefPtr<Inspector::Protocol::Debugger::Location> value)
4066	{
4067	COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set);
4068	m_result ->setObject("location"_s, value);
4069	return castState<LocationSet>();
4070	}
4071
4072	Ref<FunctionDetails> release()
4073	{
4074	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4075	COMPILE_ASSERT(sizeof(FunctionDetails) == sizeof(JSON::Object), cannot_cast);
4076
4077	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4078	auto result = WTFMove(*reinterpret_cast<Ref<FunctionDetails>*>(&jsonResult));
4079	return result;
4080	}
4081	};
4082
4083	/*
4084	* Synthetic constructor:
4085	* Ref<FunctionDetails> result = FunctionDetails::create()
4086	* .setLocation(...)
4087	* .release();
4088	*/
4089	static Builder<NoFieldsSet> create()
4090	{
4091	return Builder<NoFieldsSet>(JSON::Object::create());
4092	}
4093
4094	void setName(const String& value)
4095	{
4096	JSON::ObjectBase::setString("name"_s, value);
4097	}
4098
4099	void setDisplayName(const String& value)
4100	{
4101	JSON::ObjectBase::setString("displayName"_s, value);
4102	}
4103
4104	void setScopeChain(RefPtr<JSON::ArrayOf<Inspector::Protocol::Debugger::Scope>> value)
4105	{
4106	JSON::ObjectBase::setArray("scopeChain"_s, WTFMove(value));
4107	}
4108	};
4109
4110	/ JavaScript call frame. Array of call frames form the call stack. /
4111	class CallFrame : public JSON::ObjectBase {
4112	public:
4113	enum {
4114	NoFieldsSet = `0`,
4115	CallFrameIdSet = `1` << `0`,
4116	FunctionNameSet = `1` << `1`,
4117	LocationSet = `1` << `2`,
4118	ScopeChainSet = `1` << `3`,
4119	ThisSet = `1` << `4`,
4120	IsTailDeletedSet = `1` << `5`,
4121	AllFieldsSet = (CallFrameIdSet \| FunctionNameSet \| LocationSet \| ScopeChainSet \| ThisSet \| IsTailDeletedSet)
4122	};
4123
4124	template<int STATE>
4125	class Builder {
4126	private:
4127	RefPtr<JSON::Object> m_result;
4128
4129	template<int STEP> Builder<STATE \| STEP>& castState()
4130	{
4131	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4132	}
4133
4134	Builder(Ref</CallFrame/JSON::Object>&& object)
4135	: m_result (WTFMove(object))
4136	{
4137	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4138	}
4139	friend class CallFrame;
4140	public:
4141
4142	Builder<STATE \| CallFrameIdSet>& setCallFrameId(const String& value)
4143	{
4144	COMPILE_ASSERT(!(STATE & CallFrameIdSet), property_callFrameId_already_set);
4145	m_result ->setString("callFrameId"_s, value);
4146	return castState<CallFrameIdSet>();
4147	}
4148
4149	Builder<STATE \| FunctionNameSet>& setFunctionName(const String& value)
4150	{
4151	COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set);
4152	m_result ->setString("functionName"_s, value);
4153	return castState<FunctionNameSet>();
4154	}
4155
4156	Builder<STATE \| LocationSet>& setLocation(RefPtr<Inspector::Protocol::Debugger::Location> value)
4157	{
4158	COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set);
4159	m_result ->setObject("location"_s, value);
4160	return castState<LocationSet>();
4161	}
4162
4163	Builder<STATE \| ScopeChainSet>& setScopeChain(RefPtr<JSON::ArrayOf<Inspector::Protocol::Debugger::Scope>> value)
4164	{
4165	COMPILE_ASSERT(!(STATE & ScopeChainSet), property_scopeChain_already_set);
4166	m_result ->setArray("scopeChain"_s, value);
4167	return castState<ScopeChainSet>();
4168	}
4169
4170	Builder<STATE \| ThisSet>& setThis(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
4171	{
4172	COMPILE_ASSERT(!(STATE & ThisSet), property_this_already_set);
4173	m_result ->setObject("this"_s, value);
4174	return castState<ThisSet>();
4175	}
4176
4177	Builder<STATE \| IsTailDeletedSet>& setIsTailDeleted(bool value)
4178	{
4179	COMPILE_ASSERT(!(STATE & IsTailDeletedSet), property_isTailDeleted_already_set);
4180	m_result ->setBoolean("isTailDeleted"_s, value);
4181	return castState<IsTailDeletedSet>();
4182	}
4183
4184	Ref<CallFrame> release()
4185	{
4186	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4187	COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast);
4188
4189	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4190	auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult));
4191	return result;
4192	}
4193	};
4194
4195	/*
4196	* Synthetic constructor:
4197	* Ref<CallFrame> result = CallFrame::create()
4198	* .setCallFrameId(...)
4199	* .setFunctionName(...)
4200	* .setLocation(...)
4201	* .setScopeChain(...)
4202	* .setThis(...)
4203	* .setIsTailDeleted(...)
4204	* .release();
4205	*/
4206	static Builder<NoFieldsSet> create()
4207	{
4208	return Builder<NoFieldsSet>(JSON::Object::create());
4209	}
4210	};
4211
4212	/ Scope description. /
4213	class Scope : public JSON::ObjectBase {
4214	public:
4215	// Named after property name 'type' while generating Scope.
4216	enum class Type {
4217	Global = `99`,
4218	With = `100`,
4219	Closure = `101`,
4220	Catch = `102`,
4221	FunctionName = `103`,
4222	GlobalLexicalEnvironment = `104`,
4223	NestedLexical = `105`,
4224	}; // enum class Type
4225	enum {
4226	NoFieldsSet = `0`,
4227	ObjectSet = `1` << `0`,
4228	TypeSet = `1` << `1`,
4229	AllFieldsSet = (ObjectSet \| TypeSet)
4230	};
4231
4232	template<int STATE>
4233	class Builder {
4234	private:
4235	RefPtr<JSON::Object> m_result;
4236
4237	template<int STEP> Builder<STATE \| STEP>& castState()
4238	{
4239	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4240	}
4241
4242	Builder(Ref</Scope/JSON::Object>&& object)
4243	: m_result (WTFMove(object))
4244	{
4245	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4246	}
4247	friend class Scope;
4248	public:
4249
4250	Builder<STATE \| ObjectSet>& setObject(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
4251	{
4252	COMPILE_ASSERT(!(STATE & ObjectSet), property_object_already_set);
4253	m_result ->setObject("object"_s, value);
4254	return castState<ObjectSet>();
4255	}
4256
4257	Builder<STATE \| TypeSet>& setType(Type value)
4258	{
4259	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
4260	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
4261	return castState<TypeSet>();
4262	}
4263
4264	Ref<Scope> release()
4265	{
4266	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4267	COMPILE_ASSERT(sizeof(Scope) == sizeof(JSON::Object), cannot_cast);
4268
4269	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4270	auto result = WTFMove(*reinterpret_cast<Ref<Scope>*>(&jsonResult));
4271	return result;
4272	}
4273	};
4274
4275	/*
4276	* Synthetic constructor:
4277	* Ref<Scope> result = Scope::create()
4278	* .setObject(...)
4279	* .setType(...)
4280	* .release();
4281	*/
4282	static Builder<NoFieldsSet> create()
4283	{
4284	return Builder<NoFieldsSet>(JSON::Object::create());
4285	}
4286
4287	void setName(const String& value)
4288	{
4289	JSON::ObjectBase::setString("name"_s, value);
4290	}
4291
4292	void setLocation(RefPtr<Inspector::Protocol::Debugger::Location> value)
4293	{
4294	JSON::ObjectBase::setObject("location"_s, WTFMove(value));
4295	}
4296
4297	void setEmpty(bool value)
4298	{
4299	JSON::ObjectBase::setBoolean("empty"_s, value);
4300	}
4301	};
4302
4303	/ A sample collected by evaluating a probe breakpoint action. /
4304	class ProbeSample : public JSON::ObjectBase {
4305	public:
4306	enum {
4307	NoFieldsSet = `0`,
4308	ProbeIdSet = `1` << `0`,
4309	SampleIdSet = `1` << `1`,
4310	BatchIdSet = `1` << `2`,
4311	TimestampSet = `1` << `3`,
4312	PayloadSet = `1` << `4`,
4313	AllFieldsSet = (ProbeIdSet \| SampleIdSet \| BatchIdSet \| TimestampSet \| PayloadSet)
4314	};
4315
4316	template<int STATE>
4317	class Builder {
4318	private:
4319	RefPtr<JSON::Object> m_result;
4320
4321	template<int STEP> Builder<STATE \| STEP>& castState()
4322	{
4323	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4324	}
4325
4326	Builder(Ref</ProbeSample/JSON::Object>&& object)
4327	: m_result (WTFMove(object))
4328	{
4329	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4330	}
4331	friend class ProbeSample;
4332	public:
4333
4334	Builder<STATE \| ProbeIdSet>& setProbeId(int value)
4335	{
4336	COMPILE_ASSERT(!(STATE & ProbeIdSet), property_probeId_already_set);
4337	m_result ->setInteger("probeId"_s, value);
4338	return castState<ProbeIdSet>();
4339	}
4340
4341	Builder<STATE \| SampleIdSet>& setSampleId(int value)
4342	{
4343	COMPILE_ASSERT(!(STATE & SampleIdSet), property_sampleId_already_set);
4344	m_result ->setInteger("sampleId"_s, value);
4345	return castState<SampleIdSet>();
4346	}
4347
4348	Builder<STATE \| BatchIdSet>& setBatchId(int value)
4349	{
4350	COMPILE_ASSERT(!(STATE & BatchIdSet), property_batchId_already_set);
4351	m_result ->setInteger("batchId"_s, value);
4352	return castState<BatchIdSet>();
4353	}
4354
4355	Builder<STATE \| TimestampSet>& setTimestamp(double value)
4356	{
4357	COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
4358	m_result ->setDouble("timestamp"_s, value);
4359	return castState<TimestampSet>();
4360	}
4361
4362	Builder<STATE \| PayloadSet>& setPayload(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
4363	{
4364	COMPILE_ASSERT(!(STATE & PayloadSet), property_payload_already_set);
4365	m_result ->setObject("payload"_s, value);
4366	return castState<PayloadSet>();
4367	}
4368
4369	Ref<ProbeSample> release()
4370	{
4371	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4372	COMPILE_ASSERT(sizeof(ProbeSample) == sizeof(JSON::Object), cannot_cast);
4373
4374	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4375	auto result = WTFMove(*reinterpret_cast<Ref<ProbeSample>*>(&jsonResult));
4376	return result;
4377	}
4378	};
4379
4380	/*
4381	* Synthetic constructor:
4382	* Ref<ProbeSample> result = ProbeSample::create()
4383	* .setProbeId(...)
4384	* .setSampleId(...)
4385	* .setBatchId(...)
4386	* .setTimestamp(...)
4387	* .setPayload(...)
4388	* .release();
4389	*/
4390	static Builder<NoFieldsSet> create()
4391	{
4392	return Builder<NoFieldsSet>(JSON::Object::create());
4393	}
4394	};
4395
4396	/ The pause reason auxiliary data when paused because of an assertion. /
4397	class AssertPauseReason : public JSON::ObjectBase {
4398	public:
4399	enum {
4400	NoFieldsSet = `0`,
4401	AllFieldsSet = `0`
4402	};
4403
4404	template<int STATE>
4405	class Builder {
4406	private:
4407	RefPtr<JSON::Object> m_result;
4408
4409	template<int STEP> Builder<STATE \| STEP>& castState()
4410	{
4411	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4412	}
4413
4414	Builder(Ref</AssertPauseReason/JSON::Object>&& object)
4415	: m_result (WTFMove(object))
4416	{
4417	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4418	}
4419	friend class AssertPauseReason;
4420	public:
4421
4422	Ref<AssertPauseReason> release()
4423	{
4424	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4425	COMPILE_ASSERT(sizeof(AssertPauseReason) == sizeof(JSON::Object), cannot_cast);
4426
4427	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4428	auto result = WTFMove(*reinterpret_cast<Ref<AssertPauseReason>*>(&jsonResult));
4429	return result;
4430	}
4431	};
4432
4433	/*
4434	* Synthetic constructor:
4435	* Ref<AssertPauseReason> result = AssertPauseReason::create()
4436	* .release();
4437	*/
4438	static Builder<NoFieldsSet> create()
4439	{
4440	return Builder<NoFieldsSet>(JSON::Object::create());
4441	}
4442
4443	void setMessage(const String& value)
4444	{
4445	JSON::ObjectBase::setString("message"_s, value);
4446	}
4447	};
4448
4449	/ The pause reason auxiliary data when paused because of hitting a breakpoint. /
4450	class BreakpointPauseReason : public JSON::ObjectBase {
4451	public:
4452	enum {
4453	NoFieldsSet = `0`,
4454	BreakpointIdSet = `1` << `0`,
4455	AllFieldsSet = (BreakpointIdSet)
4456	};
4457
4458	template<int STATE>
4459	class Builder {
4460	private:
4461	RefPtr<JSON::Object> m_result;
4462
4463	template<int STEP> Builder<STATE \| STEP>& castState()
4464	{
4465	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4466	}
4467
4468	Builder(Ref</BreakpointPauseReason/JSON::Object>&& object)
4469	: m_result (WTFMove(object))
4470	{
4471	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4472	}
4473	friend class BreakpointPauseReason;
4474	public:
4475
4476	Builder<STATE \| BreakpointIdSet>& setBreakpointId(const String& value)
4477	{
4478	COMPILE_ASSERT(!(STATE & BreakpointIdSet), property_breakpointId_already_set);
4479	m_result ->setString("breakpointId"_s, value);
4480	return castState<BreakpointIdSet>();
4481	}
4482
4483	Ref<BreakpointPauseReason> release()
4484	{
4485	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4486	COMPILE_ASSERT(sizeof(BreakpointPauseReason) == sizeof(JSON::Object), cannot_cast);
4487
4488	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4489	auto result = WTFMove(*reinterpret_cast<Ref<BreakpointPauseReason>*>(&jsonResult));
4490	return result;
4491	}
4492	};
4493
4494	/*
4495	* Synthetic constructor:
4496	* Ref<BreakpointPauseReason> result = BreakpointPauseReason::create()
4497	* .setBreakpointId(...)
4498	* .release();
4499	*/
4500	static Builder<NoFieldsSet> create()
4501	{
4502	return Builder<NoFieldsSet>(JSON::Object::create());
4503	}
4504	};
4505
4506	/ The pause reason auxiliary data when paused because of a Content Security Policy directive. /
4507	class CSPViolationPauseReason : public JSON::ObjectBase {
4508	public:
4509	enum {
4510	NoFieldsSet = `0`,
4511	DirectiveSet = `1` << `0`,
4512	AllFieldsSet = (DirectiveSet)
4513	};
4514
4515	template<int STATE>
4516	class Builder {
4517	private:
4518	RefPtr<JSON::Object> m_result;
4519
4520	template<int STEP> Builder<STATE \| STEP>& castState()
4521	{
4522	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4523	}
4524
4525	Builder(Ref</CSPViolationPauseReason/JSON::Object>&& object)
4526	: m_result (WTFMove(object))
4527	{
4528	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4529	}
4530	friend class CSPViolationPauseReason;
4531	public:
4532
4533	Builder<STATE \| DirectiveSet>& setDirective(const String& value)
4534	{
4535	COMPILE_ASSERT(!(STATE & DirectiveSet), property_directive_already_set);
4536	m_result ->setString("directive"_s, value);
4537	return castState<DirectiveSet>();
4538	}
4539
4540	Ref<CSPViolationPauseReason> release()
4541	{
4542	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4543	COMPILE_ASSERT(sizeof(CSPViolationPauseReason) == sizeof(JSON::Object), cannot_cast);
4544
4545	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4546	auto result = WTFMove(*reinterpret_cast<Ref<CSPViolationPauseReason>*>(&jsonResult));
4547	return result;
4548	}
4549	};
4550
4551	/*
4552	* Synthetic constructor:
4553	* Ref<CSPViolationPauseReason> result = CSPViolationPauseReason::create()
4554	* .setDirective(...)
4555	* .release();
4556	*/
4557	static Builder<NoFieldsSet> create()
4558	{
4559	return Builder<NoFieldsSet>(JSON::Object::create());
4560	}
4561	};
4562
4563	} // Debugger
4564
4565	namespace GenericTypes {
4566	/ Search match in a resource. /
4567	class SearchMatch : public JSON::ObjectBase {
4568	public:
4569	enum {
4570	NoFieldsSet = `0`,
4571	LineNumberSet = `1` << `0`,
4572	LineContentSet = `1` << `1`,
4573	AllFieldsSet = (LineNumberSet \| LineContentSet)
4574	};
4575
4576	template<int STATE>
4577	class Builder {
4578	private:
4579	RefPtr<JSON::Object> m_result;
4580
4581	template<int STEP> Builder<STATE \| STEP>& castState()
4582	{
4583	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4584	}
4585
4586	Builder(Ref</SearchMatch/JSON::Object>&& object)
4587	: m_result (WTFMove(object))
4588	{
4589	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4590	}
4591	friend class SearchMatch;
4592	public:
4593
4594	Builder<STATE \| LineNumberSet>& setLineNumber(double value)
4595	{
4596	COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
4597	m_result ->setDouble("lineNumber"_s, value);
4598	return castState<LineNumberSet>();
4599	}
4600
4601	Builder<STATE \| LineContentSet>& setLineContent(const String& value)
4602	{
4603	COMPILE_ASSERT(!(STATE & LineContentSet), property_lineContent_already_set);
4604	m_result ->setString("lineContent"_s, value);
4605	return castState<LineContentSet>();
4606	}
4607
4608	Ref<SearchMatch> release()
4609	{
4610	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4611	COMPILE_ASSERT(sizeof(SearchMatch) == sizeof(JSON::Object), cannot_cast);
4612
4613	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4614	auto result = WTFMove(*reinterpret_cast<Ref<SearchMatch>*>(&jsonResult));
4615	return result;
4616	}
4617	};
4618
4619	/*
4620	* Synthetic constructor:
4621	* Ref<SearchMatch> result = SearchMatch::create()
4622	* .setLineNumber(...)
4623	* .setLineContent(...)
4624	* .release();
4625	*/
4626	static Builder<NoFieldsSet> create()
4627	{
4628	return Builder<NoFieldsSet>(JSON::Object::create());
4629	}
4630	};
4631
4632	} // GenericTypes
4633
4634	namespace Heap {
4635	/ Information about a garbage collection. /
4636	class GarbageCollection : public JSON::ObjectBase {
4637	public:
4638	// Named after property name 'type' while generating GarbageCollection.
4639	enum class Type {
4640	Full = `106`,
4641	Partial = `107`,
4642	}; // enum class Type
4643	enum {
4644	NoFieldsSet = `0`,
4645	TypeSet = `1` << `0`,
4646	StartTimeSet = `1` << `1`,
4647	EndTimeSet = `1` << `2`,
4648	AllFieldsSet = (TypeSet \| StartTimeSet \| EndTimeSet)
4649	};
4650
4651	template<int STATE>
4652	class Builder {
4653	private:
4654	RefPtr<JSON::Object> m_result;
4655
4656	template<int STEP> Builder<STATE \| STEP>& castState()
4657	{
4658	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4659	}
4660
4661	Builder(Ref</GarbageCollection/JSON::Object>&& object)
4662	: m_result (WTFMove(object))
4663	{
4664	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4665	}
4666	friend class GarbageCollection;
4667	public:
4668
4669	Builder<STATE \| TypeSet>& setType(Type value)
4670	{
4671	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
4672	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
4673	return castState<TypeSet>();
4674	}
4675
4676	Builder<STATE \| StartTimeSet>& setStartTime(double value)
4677	{
4678	COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
4679	m_result ->setDouble("startTime"_s, value);
4680	return castState<StartTimeSet>();
4681	}
4682
4683	Builder<STATE \| EndTimeSet>& setEndTime(double value)
4684	{
4685	COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set);
4686	m_result ->setDouble("endTime"_s, value);
4687	return castState<EndTimeSet>();
4688	}
4689
4690	Ref<GarbageCollection> release()
4691	{
4692	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4693	COMPILE_ASSERT(sizeof(GarbageCollection) == sizeof(JSON::Object), cannot_cast);
4694
4695	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4696	auto result = WTFMove(*reinterpret_cast<Ref<GarbageCollection>*>(&jsonResult));
4697	return result;
4698	}
4699	};
4700
4701	/*
4702	* Synthetic constructor:
4703	* Ref<GarbageCollection> result = GarbageCollection::create()
4704	* .setType(...)
4705	* .setStartTime(...)
4706	* .setEndTime(...)
4707	* .release();
4708	*/
4709	static Builder<NoFieldsSet> create()
4710	{
4711	return Builder<NoFieldsSet>(JSON::Object::create());
4712	}
4713	};
4714
4715	} // Heap
4716
4717	#if ENABLE(INDEXED_DATABASE)
4718	namespace IndexedDB {
4719	/ Database with an array of object stores. /
4720	class DatabaseWithObjectStores : public JSON::ObjectBase {
4721	public:
4722	enum {
4723	NoFieldsSet = `0`,
4724	NameSet = `1` << `0`,
4725	VersionSet = `1` << `1`,
4726	ObjectStoresSet = `1` << `2`,
4727	AllFieldsSet = (NameSet \| VersionSet \| ObjectStoresSet)
4728	};
4729
4730	template<int STATE>
4731	class Builder {
4732	private:
4733	RefPtr<JSON::Object> m_result;
4734
4735	template<int STEP> Builder<STATE \| STEP>& castState()
4736	{
4737	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4738	}
4739
4740	Builder(Ref</DatabaseWithObjectStores/JSON::Object>&& object)
4741	: m_result (WTFMove(object))
4742	{
4743	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4744	}
4745	friend class DatabaseWithObjectStores;
4746	public:
4747
4748	Builder<STATE \| NameSet>& setName(const String& value)
4749	{
4750	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
4751	m_result ->setString("name"_s, value);
4752	return castState<NameSet>();
4753	}
4754
4755	Builder<STATE \| VersionSet>& setVersion(double value)
4756	{
4757	COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
4758	m_result ->setDouble("version"_s, value);
4759	return castState<VersionSet>();
4760	}
4761
4762	Builder<STATE \| ObjectStoresSet>& setObjectStores(RefPtr<JSON::ArrayOf<Inspector::Protocol::IndexedDB::ObjectStore>> value)
4763	{
4764	COMPILE_ASSERT(!(STATE & ObjectStoresSet), property_objectStores_already_set);
4765	m_result ->setArray("objectStores"_s, value);
4766	return castState<ObjectStoresSet>();
4767	}
4768
4769	Ref<DatabaseWithObjectStores> release()
4770	{
4771	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4772	COMPILE_ASSERT(sizeof(DatabaseWithObjectStores) == sizeof(JSON::Object), cannot_cast);
4773
4774	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4775	auto result = WTFMove(*reinterpret_cast<Ref<DatabaseWithObjectStores>*>(&jsonResult));
4776	return result;
4777	}
4778	};
4779
4780	/*
4781	* Synthetic constructor:
4782	* Ref<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
4783	* .setName(...)
4784	* .setVersion(...)
4785	* .setObjectStores(...)
4786	* .release();
4787	*/
4788	static Builder<NoFieldsSet> create()
4789	{
4790	return Builder<NoFieldsSet>(JSON::Object::create());
4791	}
4792	};
4793
4794	/ Object store. /
4795	class ObjectStore : public JSON::ObjectBase {
4796	public:
4797	enum {
4798	NoFieldsSet = `0`,
4799	NameSet = `1` << `0`,
4800	KeyPathSet = `1` << `1`,
4801	AutoIncrementSet = `1` << `2`,
4802	IndexesSet = `1` << `3`,
4803	AllFieldsSet = (NameSet \| KeyPathSet \| AutoIncrementSet \| IndexesSet)
4804	};
4805
4806	template<int STATE>
4807	class Builder {
4808	private:
4809	RefPtr<JSON::Object> m_result;
4810
4811	template<int STEP> Builder<STATE \| STEP>& castState()
4812	{
4813	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4814	}
4815
4816	Builder(Ref</ObjectStore/JSON::Object>&& object)
4817	: m_result (WTFMove(object))
4818	{
4819	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4820	}
4821	friend class ObjectStore;
4822	public:
4823
4824	Builder<STATE \| NameSet>& setName(const String& value)
4825	{
4826	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
4827	m_result ->setString("name"_s, value);
4828	return castState<NameSet>();
4829	}
4830
4831	Builder<STATE \| KeyPathSet>& setKeyPath(RefPtr<Inspector::Protocol::IndexedDB::KeyPath> value)
4832	{
4833	COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set);
4834	m_result ->setObject("keyPath"_s, value);
4835	return castState<KeyPathSet>();
4836	}
4837
4838	Builder<STATE \| AutoIncrementSet>& setAutoIncrement(bool value)
4839	{
4840	COMPILE_ASSERT(!(STATE & AutoIncrementSet), property_autoIncrement_already_set);
4841	m_result ->setBoolean("autoIncrement"_s, value);
4842	return castState<AutoIncrementSet>();
4843	}
4844
4845	Builder<STATE \| IndexesSet>& setIndexes(RefPtr<JSON::ArrayOf<Inspector::Protocol::IndexedDB::ObjectStoreIndex>> value)
4846	{
4847	COMPILE_ASSERT(!(STATE & IndexesSet), property_indexes_already_set);
4848	m_result ->setArray("indexes"_s, value);
4849	return castState<IndexesSet>();
4850	}
4851
4852	Ref<ObjectStore> release()
4853	{
4854	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4855	COMPILE_ASSERT(sizeof(ObjectStore) == sizeof(JSON::Object), cannot_cast);
4856
4857	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4858	auto result = WTFMove(*reinterpret_cast<Ref<ObjectStore>*>(&jsonResult));
4859	return result;
4860	}
4861	};
4862
4863	/*
4864	* Synthetic constructor:
4865	* Ref<ObjectStore> result = ObjectStore::create()
4866	* .setName(...)
4867	* .setKeyPath(...)
4868	* .setAutoIncrement(...)
4869	* .setIndexes(...)
4870	* .release();
4871	*/
4872	static Builder<NoFieldsSet> create()
4873	{
4874	return Builder<NoFieldsSet>(JSON::Object::create());
4875	}
4876	};
4877
4878	/ Object store index. /
4879	class ObjectStoreIndex : public JSON::ObjectBase {
4880	public:
4881	enum {
4882	NoFieldsSet = `0`,
4883	NameSet = `1` << `0`,
4884	KeyPathSet = `1` << `1`,
4885	UniqueSet = `1` << `2`,
4886	MultiEntrySet = `1` << `3`,
4887	AllFieldsSet = (NameSet \| KeyPathSet \| UniqueSet \| MultiEntrySet)
4888	};
4889
4890	template<int STATE>
4891	class Builder {
4892	private:
4893	RefPtr<JSON::Object> m_result;
4894
4895	template<int STEP> Builder<STATE \| STEP>& castState()
4896	{
4897	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4898	}
4899
4900	Builder(Ref</ObjectStoreIndex/JSON::Object>&& object)
4901	: m_result (WTFMove(object))
4902	{
4903	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4904	}
4905	friend class ObjectStoreIndex;
4906	public:
4907
4908	Builder<STATE \| NameSet>& setName(const String& value)
4909	{
4910	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
4911	m_result ->setString("name"_s, value);
4912	return castState<NameSet>();
4913	}
4914
4915	Builder<STATE \| KeyPathSet>& setKeyPath(RefPtr<Inspector::Protocol::IndexedDB::KeyPath> value)
4916	{
4917	COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set);
4918	m_result ->setObject("keyPath"_s, value);
4919	return castState<KeyPathSet>();
4920	}
4921
4922	Builder<STATE \| UniqueSet>& setUnique(bool value)
4923	{
4924	COMPILE_ASSERT(!(STATE & UniqueSet), property_unique_already_set);
4925	m_result ->setBoolean("unique"_s, value);
4926	return castState<UniqueSet>();
4927	}
4928
4929	Builder<STATE \| MultiEntrySet>& setMultiEntry(bool value)
4930	{
4931	COMPILE_ASSERT(!(STATE & MultiEntrySet), property_multiEntry_already_set);
4932	m_result ->setBoolean("multiEntry"_s, value);
4933	return castState<MultiEntrySet>();
4934	}
4935
4936	Ref<ObjectStoreIndex> release()
4937	{
4938	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4939	COMPILE_ASSERT(sizeof(ObjectStoreIndex) == sizeof(JSON::Object), cannot_cast);
4940
4941	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4942	auto result = WTFMove(*reinterpret_cast<Ref<ObjectStoreIndex>*>(&jsonResult));
4943	return result;
4944	}
4945	};
4946
4947	/*
4948	* Synthetic constructor:
4949	* Ref<ObjectStoreIndex> result = ObjectStoreIndex::create()
4950	* .setName(...)
4951	* .setKeyPath(...)
4952	* .setUnique(...)
4953	* .setMultiEntry(...)
4954	* .release();
4955	*/
4956	static Builder<NoFieldsSet> create()
4957	{
4958	return Builder<NoFieldsSet>(JSON::Object::create());
4959	}
4960	};
4961
4962	/ Key. /
4963	class Key : public JSON::ObjectBase {
4964	public:
4965	// Named after property name 'type' while generating Key.
4966	enum class Type {
4967	Number = `108`,
4968	String = `109`,
4969	Date = `84`,
4970	Array = `110`,
4971	}; // enum class Type
4972	enum {
4973	NoFieldsSet = `0`,
4974	TypeSet = `1` << `0`,
4975	AllFieldsSet = (TypeSet)
4976	};
4977
4978	template<int STATE>
4979	class Builder {
4980	private:
4981	RefPtr<JSON::Object> m_result;
4982
4983	template<int STEP> Builder<STATE \| STEP>& castState()
4984	{
4985	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4986	}
4987
4988	Builder(Ref</Key/JSON::Object>&& object)
4989	: m_result (WTFMove(object))
4990	{
4991	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4992	}
4993	friend class Key;
4994	public:
4995
4996	Builder<STATE \| TypeSet>& setType(Type value)
4997	{
4998	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
4999	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
5000	return castState<TypeSet>();
5001	}
5002
5003	Ref<Key> release()
5004	{
5005	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5006	COMPILE_ASSERT(sizeof(Key) == sizeof(JSON::Object), cannot_cast);
5007
5008	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5009	auto result = WTFMove(*reinterpret_cast<Ref<Key>*>(&jsonResult));
5010	return result;
5011	}
5012	};
5013
5014	/*
5015	* Synthetic constructor:
5016	* Ref<Key> result = Key::create()
5017	* .setType(...)
5018	* .release();
5019	*/
5020	static Builder<NoFieldsSet> create()
5021	{
5022	return Builder<NoFieldsSet>(JSON::Object::create());
5023	}
5024
5025	void setNumber(double value)
5026	{
5027	JSON::ObjectBase::setDouble("number"_s, value);
5028	}
5029
5030	void setString(const String& value)
5031	{
5032	JSON::ObjectBase::setString("string"_s, value);
5033	}
5034
5035	void setDate(double value)
5036	{
5037	JSON::ObjectBase::setDouble("date"_s, value);
5038	}
5039
5040	void setArray(RefPtr<JSON::ArrayOf<Inspector::Protocol::IndexedDB::Key>> value)
5041	{
5042	JSON::ObjectBase::setArray("array"_s, WTFMove(value));
5043	}
5044	};
5045
5046	/ Key range. /
5047	class KeyRange : public JSON::ObjectBase {
5048	public:
5049	enum {
5050	NoFieldsSet = `0`,
5051	LowerOpenSet = `1` << `0`,
5052	UpperOpenSet = `1` << `1`,
5053	AllFieldsSet = (LowerOpenSet \| UpperOpenSet)
5054	};
5055
5056	template<int STATE>
5057	class Builder {
5058	private:
5059	RefPtr<JSON::Object> m_result;
5060
5061	template<int STEP> Builder<STATE \| STEP>& castState()
5062	{
5063	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5064	}
5065
5066	Builder(Ref</KeyRange/JSON::Object>&& object)
5067	: m_result (WTFMove(object))
5068	{
5069	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5070	}
5071	friend class KeyRange;
5072	public:
5073
5074	Builder<STATE \| LowerOpenSet>& setLowerOpen(bool value)
5075	{
5076	COMPILE_ASSERT(!(STATE & LowerOpenSet), property_lowerOpen_already_set);
5077	m_result ->setBoolean("lowerOpen"_s, value);
5078	return castState<LowerOpenSet>();
5079	}
5080
5081	Builder<STATE \| UpperOpenSet>& setUpperOpen(bool value)
5082	{
5083	COMPILE_ASSERT(!(STATE & UpperOpenSet), property_upperOpen_already_set);
5084	m_result ->setBoolean("upperOpen"_s, value);
5085	return castState<UpperOpenSet>();
5086	}
5087
5088	Ref<KeyRange> release()
5089	{
5090	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5091	COMPILE_ASSERT(sizeof(KeyRange) == sizeof(JSON::Object), cannot_cast);
5092
5093	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5094	auto result = WTFMove(*reinterpret_cast<Ref<KeyRange>*>(&jsonResult));
5095	return result;
5096	}
5097	};
5098
5099	/*
5100	* Synthetic constructor:
5101	* Ref<KeyRange> result = KeyRange::create()
5102	* .setLowerOpen(...)
5103	* .setUpperOpen(...)
5104	* .release();
5105	*/
5106	static Builder<NoFieldsSet> create()
5107	{
5108	return Builder<NoFieldsSet>(JSON::Object::create());
5109	}
5110
5111	void setLower(RefPtr<Inspector::Protocol::IndexedDB::Key> value)
5112	{
5113	JSON::ObjectBase::setObject("lower"_s, WTFMove(value));
5114	}
5115
5116	void setUpper(RefPtr<Inspector::Protocol::IndexedDB::Key> value)
5117	{
5118	JSON::ObjectBase::setObject("upper"_s, WTFMove(value));
5119	}
5120	};
5121
5122	/ Data entry. /
5123	class DataEntry : public JSON::ObjectBase {
5124	public:
5125	enum {
5126	NoFieldsSet = `0`,
5127	KeySet = `1` << `0`,
5128	PrimaryKeySet = `1` << `1`,
5129	ValueSet = `1` << `2`,
5130	AllFieldsSet = (KeySet \| PrimaryKeySet \| ValueSet)
5131	};
5132
5133	template<int STATE>
5134	class Builder {
5135	private:
5136	RefPtr<JSON::Object> m_result;
5137
5138	template<int STEP> Builder<STATE \| STEP>& castState()
5139	{
5140	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5141	}
5142
5143	Builder(Ref</DataEntry/JSON::Object>&& object)
5144	: m_result (WTFMove(object))
5145	{
5146	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5147	}
5148	friend class DataEntry;
5149	public:
5150
5151	Builder<STATE \| KeySet>& setKey(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
5152	{
5153	COMPILE_ASSERT(!(STATE & KeySet), property_key_already_set);
5154	m_result ->setObject("key"_s, value);
5155	return castState<KeySet>();
5156	}
5157
5158	Builder<STATE \| PrimaryKeySet>& setPrimaryKey(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
5159	{
5160	COMPILE_ASSERT(!(STATE & PrimaryKeySet), property_primaryKey_already_set);
5161	m_result ->setObject("primaryKey"_s, value);
5162	return castState<PrimaryKeySet>();
5163	}
5164
5165	Builder<STATE \| ValueSet>& setValue(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
5166	{
5167	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
5168	m_result ->setObject("value"_s, value);
5169	return castState<ValueSet>();
5170	}
5171
5172	Ref<DataEntry> release()
5173	{
5174	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5175	COMPILE_ASSERT(sizeof(DataEntry) == sizeof(JSON::Object), cannot_cast);
5176
5177	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5178	auto result = WTFMove(*reinterpret_cast<Ref<DataEntry>*>(&jsonResult));
5179	return result;
5180	}
5181	};
5182
5183	/*
5184	* Synthetic constructor:
5185	* Ref<DataEntry> result = DataEntry::create()
5186	* .setKey(...)
5187	* .setPrimaryKey(...)
5188	* .setValue(...)
5189	* .release();
5190	*/
5191	static Builder<NoFieldsSet> create()
5192	{
5193	return Builder<NoFieldsSet>(JSON::Object::create());
5194	}
5195	};
5196
5197	/ Key path. /
5198	class KeyPath : public JSON::ObjectBase {
5199	public:
5200	// Named after property name 'type' while generating KeyPath.
5201	enum class Type {
5202	Null = `111`,
5203	String = `109`,
5204	Array = `110`,
5205	}; // enum class Type
5206	enum {
5207	NoFieldsSet = `0`,
5208	TypeSet = `1` << `0`,
5209	AllFieldsSet = (TypeSet)
5210	};
5211
5212	template<int STATE>
5213	class Builder {
5214	private:
5215	RefPtr<JSON::Object> m_result;
5216
5217	template<int STEP> Builder<STATE \| STEP>& castState()
5218	{
5219	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5220	}
5221
5222	Builder(Ref</KeyPath/JSON::Object>&& object)
5223	: m_result (WTFMove(object))
5224	{
5225	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5226	}
5227	friend class KeyPath;
5228	public:
5229
5230	Builder<STATE \| TypeSet>& setType(Type value)
5231	{
5232	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5233	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
5234	return castState<TypeSet>();
5235	}
5236
5237	Ref<KeyPath> release()
5238	{
5239	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5240	COMPILE_ASSERT(sizeof(KeyPath) == sizeof(JSON::Object), cannot_cast);
5241
5242	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5243	auto result = WTFMove(*reinterpret_cast<Ref<KeyPath>*>(&jsonResult));
5244	return result;
5245	}
5246	};
5247
5248	/*
5249	* Synthetic constructor:
5250	* Ref<KeyPath> result = KeyPath::create()
5251	* .setType(...)
5252	* .release();
5253	*/
5254	static Builder<NoFieldsSet> create()
5255	{
5256	return Builder<NoFieldsSet>(JSON::Object::create());
5257	}
5258
5259	void setString(const String& value)
5260	{
5261	JSON::ObjectBase::setString("string"_s, value);
5262	}
5263
5264	void setArray(RefPtr<JSON::ArrayOf<String>> value)
5265	{
5266	JSON::ObjectBase::setArray("array"_s, WTFMove(value));
5267	}
5268	};
5269
5270	} // IndexedDB
5271	#endif // ENABLE(INDEXED_DATABASE)
5272
5273	namespace LayerTree {
5274	/ A rectangle. /
5275	class IntRect : public JSON::ObjectBase {
5276	public:
5277	enum {
5278	NoFieldsSet = `0`,
5279	XSet = `1` << `0`,
5280	YSet = `1` << `1`,
5281	WidthSet = `1` << `2`,
5282	HeightSet = `1` << `3`,
5283	AllFieldsSet = (XSet \| YSet \| WidthSet \| HeightSet)
5284	};
5285
5286	template<int STATE>
5287	class Builder {
5288	private:
5289	RefPtr<JSON::Object> m_result;
5290
5291	template<int STEP> Builder<STATE \| STEP>& castState()
5292	{
5293	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5294	}
5295
5296	Builder(Ref</IntRect/JSON::Object>&& object)
5297	: m_result (WTFMove(object))
5298	{
5299	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5300	}
5301	friend class IntRect;
5302	public:
5303
5304	Builder<STATE \| XSet>& setX(int value)
5305	{
5306	COMPILE_ASSERT(!(STATE & XSet), property_x_already_set);
5307	m_result ->setInteger("x"_s, value);
5308	return castState<XSet>();
5309	}
5310
5311	Builder<STATE \| YSet>& setY(int value)
5312	{
5313	COMPILE_ASSERT(!(STATE & YSet), property_y_already_set);
5314	m_result ->setInteger("y"_s, value);
5315	return castState<YSet>();
5316	}
5317
5318	Builder<STATE \| WidthSet>& setWidth(int value)
5319	{
5320	COMPILE_ASSERT(!(STATE & WidthSet), property_width_already_set);
5321	m_result ->setInteger("width"_s, value);
5322	return castState<WidthSet>();
5323	}
5324
5325	Builder<STATE \| HeightSet>& setHeight(int value)
5326	{
5327	COMPILE_ASSERT(!(STATE & HeightSet), property_height_already_set);
5328	m_result ->setInteger("height"_s, value);
5329	return castState<HeightSet>();
5330	}
5331
5332	Ref<IntRect> release()
5333	{
5334	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5335	COMPILE_ASSERT(sizeof(IntRect) == sizeof(JSON::Object), cannot_cast);
5336
5337	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5338	auto result = WTFMove(*reinterpret_cast<Ref<IntRect>*>(&jsonResult));
5339	return result;
5340	}
5341	};
5342
5343	/*
5344	* Synthetic constructor:
5345	* Ref<IntRect> result = IntRect::create()
5346	* .setX(...)
5347	* .setY(...)
5348	* .setWidth(...)
5349	* .setHeight(...)
5350	* .release();
5351	*/
5352	static Builder<NoFieldsSet> create()
5353	{
5354	return Builder<NoFieldsSet>(JSON::Object::create());
5355	}
5356	};
5357
5358	/ Information about a compositing layer. /
5359	class Layer : public JSON::ObjectBase {
5360	public:
5361	enum {
5362	NoFieldsSet = `0`,
5363	LayerIdSet = `1` << `0`,
5364	NodeIdSet = `1` << `1`,
5365	BoundsSet = `1` << `2`,
5366	PaintCountSet = `1` << `3`,
5367	MemorySet = `1` << `4`,
5368	CompositedBoundsSet = `1` << `5`,
5369	AllFieldsSet = (LayerIdSet \| NodeIdSet \| BoundsSet \| PaintCountSet \| MemorySet \| CompositedBoundsSet)
5370	};
5371
5372	template<int STATE>
5373	class Builder {
5374	private:
5375	RefPtr<JSON::Object> m_result;
5376
5377	template<int STEP> Builder<STATE \| STEP>& castState()
5378	{
5379	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5380	}
5381
5382	Builder(Ref</Layer/JSON::Object>&& object)
5383	: m_result (WTFMove(object))
5384	{
5385	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5386	}
5387	friend class Layer;
5388	public:
5389
5390	Builder<STATE \| LayerIdSet>& setLayerId(const String& value)
5391	{
5392	COMPILE_ASSERT(!(STATE & LayerIdSet), property_layerId_already_set);
5393	m_result ->setString("layerId"_s, value);
5394	return castState<LayerIdSet>();
5395	}
5396
5397	Builder<STATE \| NodeIdSet>& setNodeId(int value)
5398	{
5399	COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
5400	m_result ->setInteger("nodeId"_s, value);
5401	return castState<NodeIdSet>();
5402	}
5403
5404	Builder<STATE \| BoundsSet>& setBounds(RefPtr<Inspector::Protocol::LayerTree::IntRect> value)
5405	{
5406	COMPILE_ASSERT(!(STATE & BoundsSet), property_bounds_already_set);
5407	m_result ->setObject("bounds"_s, value);
5408	return castState<BoundsSet>();
5409	}
5410
5411	Builder<STATE \| PaintCountSet>& setPaintCount(int value)
5412	{
5413	COMPILE_ASSERT(!(STATE & PaintCountSet), property_paintCount_already_set);
5414	m_result ->setInteger("paintCount"_s, value);
5415	return castState<PaintCountSet>();
5416	}
5417
5418	Builder<STATE \| MemorySet>& setMemory(int value)
5419	{
5420	COMPILE_ASSERT(!(STATE & MemorySet), property_memory_already_set);
5421	m_result ->setInteger("memory"_s, value);
5422	return castState<MemorySet>();
5423	}
5424
5425	Builder<STATE \| CompositedBoundsSet>& setCompositedBounds(RefPtr<Inspector::Protocol::LayerTree::IntRect> value)
5426	{
5427	COMPILE_ASSERT(!(STATE & CompositedBoundsSet), property_compositedBounds_already_set);
5428	m_result ->setObject("compositedBounds"_s, value);
5429	return castState<CompositedBoundsSet>();
5430	}
5431
5432	Ref<Layer> release()
5433	{
5434	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5435	COMPILE_ASSERT(sizeof(Layer) == sizeof(JSON::Object), cannot_cast);
5436
5437	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5438	auto result = WTFMove(*reinterpret_cast<Ref<Layer>*>(&jsonResult));
5439	return result;
5440	}
5441	};
5442
5443	/*
5444	* Synthetic constructor:
5445	* Ref<Layer> result = Layer::create()
5446	* .setLayerId(...)
5447	* .setNodeId(...)
5448	* .setBounds(...)
5449	* .setPaintCount(...)
5450	* .setMemory(...)
5451	* .setCompositedBounds(...)
5452	* .release();
5453	*/
5454	static Builder<NoFieldsSet> create()
5455	{
5456	return Builder<NoFieldsSet>(JSON::Object::create());
5457	}
5458
5459	void setIsInShadowTree(bool value)
5460	{
5461	JSON::ObjectBase::setBoolean("isInShadowTree"_s, value);
5462	}
5463
5464	void setIsReflection(bool value)
5465	{
5466	JSON::ObjectBase::setBoolean("isReflection"_s, value);
5467	}
5468
5469	void setIsGeneratedContent(bool value)
5470	{
5471	JSON::ObjectBase::setBoolean("isGeneratedContent"_s, value);
5472	}
5473
5474	void setIsAnonymous(bool value)
5475	{
5476	JSON::ObjectBase::setBoolean("isAnonymous"_s, value);
5477	}
5478
5479	void setPseudoElementId(const String& value)
5480	{
5481	JSON::ObjectBase::setString("pseudoElementId"_s, value);
5482	}
5483
5484	void setPseudoElement(const String& value)
5485	{
5486	JSON::ObjectBase::setString("pseudoElement"_s, value);
5487	}
5488	};
5489
5490	/ An object containing the reasons why the layer was composited as properties. /
5491	class CompositingReasons : public JSON::ObjectBase {
5492	public:
5493	enum {
5494	NoFieldsSet = `0`,
5495	AllFieldsSet = `0`
5496	};
5497
5498	template<int STATE>
5499	class Builder {
5500	private:
5501	RefPtr<JSON::Object> m_result;
5502
5503	template<int STEP> Builder<STATE \| STEP>& castState()
5504	{
5505	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5506	}
5507
5508	Builder(Ref</CompositingReasons/JSON::Object>&& object)
5509	: m_result (WTFMove(object))
5510	{
5511	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5512	}
5513	friend class CompositingReasons;
5514	public:
5515
5516	Ref<CompositingReasons> release()
5517	{
5518	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5519	COMPILE_ASSERT(sizeof(CompositingReasons) == sizeof(JSON::Object), cannot_cast);
5520
5521	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5522	auto result = WTFMove(*reinterpret_cast<Ref<CompositingReasons>*>(&jsonResult));
5523	return result;
5524	}
5525	};
5526
5527	/*
5528	* Synthetic constructor:
5529	* Ref<CompositingReasons> result = CompositingReasons::create()
5530	* .release();
5531	*/
5532	static Builder<NoFieldsSet> create()
5533	{
5534	return Builder<NoFieldsSet>(JSON::Object::create());
5535	}
5536
5537	void setTransform3D(bool value)
5538	{
5539	JSON::ObjectBase::setBoolean("transform3D"_s, value);
5540	}
5541
5542	void setVideo(bool value)
5543	{
5544	JSON::ObjectBase::setBoolean("video"_s, value);
5545	}
5546
5547	void setCanvas(bool value)
5548	{
5549	JSON::ObjectBase::setBoolean("canvas"_s, value);
5550	}
5551
5552	void setPlugin(bool value)
5553	{
5554	JSON::ObjectBase::setBoolean("plugin"_s, value);
5555	}
5556
5557	void setIFrame(bool value)
5558	{
5559	JSON::ObjectBase::setBoolean("iFrame"_s, value);
5560	}
5561
5562	void setBackfaceVisibilityHidden(bool value)
5563	{
5564	JSON::ObjectBase::setBoolean("backfaceVisibilityHidden"_s, value);
5565	}
5566
5567	void setClipsCompositingDescendants(bool value)
5568	{
5569	JSON::ObjectBase::setBoolean("clipsCompositingDescendants"_s, value);
5570	}
5571
5572	void setAnimation(bool value)
5573	{
5574	JSON::ObjectBase::setBoolean("animation"_s, value);
5575	}
5576
5577	void setFilters(bool value)
5578	{
5579	JSON::ObjectBase::setBoolean("filters"_s, value);
5580	}
5581
5582	void setPositionFixed(bool value)
5583	{
5584	JSON::ObjectBase::setBoolean("positionFixed"_s, value);
5585	}
5586
5587	void setPositionSticky(bool value)
5588	{
5589	JSON::ObjectBase::setBoolean("positionSticky"_s, value);
5590	}
5591
5592	void setOverflowScrollingTouch(bool value)
5593	{
5594	JSON::ObjectBase::setBoolean("overflowScrollingTouch"_s, value);
5595	}
5596
5597	void setStacking(bool value)
5598	{
5599	JSON::ObjectBase::setBoolean("stacking"_s, value);
5600	}
5601
5602	void setOverlap(bool value)
5603	{
5604	JSON::ObjectBase::setBoolean("overlap"_s, value);
5605	}
5606
5607	void setNegativeZIndexChildren(bool value)
5608	{
5609	JSON::ObjectBase::setBoolean("negativeZIndexChildren"_s, value);
5610	}
5611
5612	void setTransformWithCompositedDescendants(bool value)
5613	{
5614	JSON::ObjectBase::setBoolean("transformWithCompositedDescendants"_s, value);
5615	}
5616
5617	void setOpacityWithCompositedDescendants(bool value)
5618	{
5619	JSON::ObjectBase::setBoolean("opacityWithCompositedDescendants"_s, value);
5620	}
5621
5622	void setMaskWithCompositedDescendants(bool value)
5623	{
5624	JSON::ObjectBase::setBoolean("maskWithCompositedDescendants"_s, value);
5625	}
5626
5627	void setReflectionWithCompositedDescendants(bool value)
5628	{
5629	JSON::ObjectBase::setBoolean("reflectionWithCompositedDescendants"_s, value);
5630	}
5631
5632	void setFilterWithCompositedDescendants(bool value)
5633	{
5634	JSON::ObjectBase::setBoolean("filterWithCompositedDescendants"_s, value);
5635	}
5636
5637	void setBlendingWithCompositedDescendants(bool value)
5638	{
5639	JSON::ObjectBase::setBoolean("blendingWithCompositedDescendants"_s, value);
5640	}
5641
5642	void setIsolatesCompositedBlendingDescendants(bool value)
5643	{
5644	JSON::ObjectBase::setBoolean("isolatesCompositedBlendingDescendants"_s, value);
5645	}
5646
5647	void setPerspective(bool value)
5648	{
5649	JSON::ObjectBase::setBoolean("perspective"_s, value);
5650	}
5651
5652	void setPreserve3D(bool value)
5653	{
5654	JSON::ObjectBase::setBoolean("preserve3D"_s, value);
5655	}
5656
5657	void setWillChange(bool value)
5658	{
5659	JSON::ObjectBase::setBoolean("willChange"_s, value);
5660	}
5661
5662	void setRoot(bool value)
5663	{
5664	JSON::ObjectBase::setBoolean("root"_s, value);
5665	}
5666
5667	void setBlending(bool value)
5668	{
5669	JSON::ObjectBase::setBoolean("blending"_s, value);
5670	}
5671	};
5672
5673	} // LayerTree
5674
5675	#if ENABLE(RESOURCE_USAGE)
5676	namespace Memory {
5677	class Event : public JSON::ObjectBase {
5678	public:
5679	enum {
5680	NoFieldsSet = `0`,
5681	TimestampSet = `1` << `0`,
5682	CategoriesSet = `1` << `1`,
5683	AllFieldsSet = (TimestampSet \| CategoriesSet)
5684	};
5685
5686	template<int STATE>
5687	class Builder {
5688	private:
5689	RefPtr<JSON::Object> m_result;
5690
5691	template<int STEP> Builder<STATE \| STEP>& castState()
5692	{
5693	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5694	}
5695
5696	Builder(Ref</Event/JSON::Object>&& object)
5697	: m_result (WTFMove(object))
5698	{
5699	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5700	}
5701	friend class Event;
5702	public:
5703
5704	Builder<STATE \| TimestampSet>& setTimestamp(double value)
5705	{
5706	COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
5707	m_result ->setDouble("timestamp"_s, value);
5708	return castState<TimestampSet>();
5709	}
5710
5711	Builder<STATE \| CategoriesSet>& setCategories(RefPtr<JSON::ArrayOf<Inspector::Protocol::Memory::CategoryData>> value)
5712	{
5713	COMPILE_ASSERT(!(STATE & CategoriesSet), property_categories_already_set);
5714	m_result ->setArray("categories"_s, value);
5715	return castState<CategoriesSet>();
5716	}
5717
5718	Ref<Event> release()
5719	{
5720	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5721	COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
5722
5723	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5724	auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
5725	return result;
5726	}
5727	};
5728
5729	/*
5730	* Synthetic constructor:
5731	* Ref<Event> result = Event::create()
5732	* .setTimestamp(...)
5733	* .setCategories(...)
5734	* .release();
5735	*/
5736	static Builder<NoFieldsSet> create()
5737	{
5738	return Builder<NoFieldsSet>(JSON::Object::create());
5739	}
5740	};
5741
5742	class CategoryData : public JSON::ObjectBase {
5743	public:
5744	// Named after property name 'type' while generating CategoryData.
5745	enum class Type {
5746	JavaScript = `35`,
5747	JIT = `112`,
5748	Images = `113`,
5749	Layers = `114`,
5750	Page = `81`,
5751	Other = `47`,
5752	}; // enum class Type
5753	enum {
5754	NoFieldsSet = `0`,
5755	TypeSet = `1` << `0`,
5756	SizeSet = `1` << `1`,
5757	AllFieldsSet = (TypeSet \| SizeSet)
5758	};
5759
5760	template<int STATE>
5761	class Builder {
5762	private:
5763	RefPtr<JSON::Object> m_result;
5764
5765	template<int STEP> Builder<STATE \| STEP>& castState()
5766	{
5767	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5768	}
5769
5770	Builder(Ref</CategoryData/JSON::Object>&& object)
5771	: m_result (WTFMove(object))
5772	{
5773	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5774	}
5775	friend class CategoryData;
5776	public:
5777
5778	Builder<STATE \| TypeSet>& setType(Type value)
5779	{
5780	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5781	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
5782	return castState<TypeSet>();
5783	}
5784
5785	Builder<STATE \| SizeSet>& setSize(double value)
5786	{
5787	COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
5788	m_result ->setDouble("size"_s, value);
5789	return castState<SizeSet>();
5790	}
5791
5792	Ref<CategoryData> release()
5793	{
5794	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5795	COMPILE_ASSERT(sizeof(CategoryData) == sizeof(JSON::Object), cannot_cast);
5796
5797	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5798	auto result = WTFMove(*reinterpret_cast<Ref<CategoryData>*>(&jsonResult));
5799	return result;
5800	}
5801	};
5802
5803	/*
5804	* Synthetic constructor:
5805	* Ref<CategoryData> result = CategoryData::create()
5806	* .setType(...)
5807	* .setSize(...)
5808	* .release();
5809	*/
5810	static Builder<NoFieldsSet> create()
5811	{
5812	return Builder<NoFieldsSet>(JSON::Object::create());
5813	}
5814	};
5815
5816	} // Memory
5817	#endif // ENABLE(RESOURCE_USAGE)
5818
5819	namespace Network {
5820	/ Timing information for the request. /
5821	class ResourceTiming : public JSON::ObjectBase {
5822	public:
5823	enum {
5824	NoFieldsSet = `0`,
5825	StartTimeSet = `1` << `0`,
5826	RedirectStartSet = `1` << `1`,
5827	RedirectEndSet = `1` << `2`,
5828	FetchStartSet = `1` << `3`,
5829	DomainLookupStartSet = `1` << `4`,
5830	DomainLookupEndSet = `1` << `5`,
5831	ConnectStartSet = `1` << `6`,
5832	ConnectEndSet = `1` << `7`,
5833	SecureConnectionStartSet = `1` << `8`,
5834	RequestStartSet = `1` << `9`,
5835	ResponseStartSet = `1` << `10`,
5836	ResponseEndSet = `1` << `11`,
5837	AllFieldsSet = (StartTimeSet \| RedirectStartSet \| RedirectEndSet \| FetchStartSet \| DomainLookupStartSet \| DomainLookupEndSet \| ConnectStartSet \| ConnectEndSet \| SecureConnectionStartSet \| RequestStartSet \| ResponseStartSet \| ResponseEndSet)
5838	};
5839
5840	template<int STATE>
5841	class Builder {
5842	private:
5843	RefPtr<JSON::Object> m_result;
5844
5845	template<int STEP> Builder<STATE \| STEP>& castState()
5846	{
5847	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5848	}
5849
5850	Builder(Ref</ResourceTiming/JSON::Object>&& object)
5851	: m_result (WTFMove(object))
5852	{
5853	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5854	}
5855	friend class ResourceTiming;
5856	public:
5857
5858	Builder<STATE \| StartTimeSet>& setStartTime(double value)
5859	{
5860	COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
5861	m_result ->setDouble("startTime"_s, value);
5862	return castState<StartTimeSet>();
5863	}
5864
5865	Builder<STATE \| RedirectStartSet>& setRedirectStart(double value)
5866	{
5867	COMPILE_ASSERT(!(STATE & RedirectStartSet), property_redirectStart_already_set);
5868	m_result ->setDouble("redirectStart"_s, value);
5869	return castState<RedirectStartSet>();
5870	}
5871
5872	Builder<STATE \| RedirectEndSet>& setRedirectEnd(double value)
5873	{
5874	COMPILE_ASSERT(!(STATE & RedirectEndSet), property_redirectEnd_already_set);
5875	m_result ->setDouble("redirectEnd"_s, value);
5876	return castState<RedirectEndSet>();
5877	}
5878
5879	Builder<STATE \| FetchStartSet>& setFetchStart(double value)
5880	{
5881	COMPILE_ASSERT(!(STATE & FetchStartSet), property_fetchStart_already_set);
5882	m_result ->setDouble("fetchStart"_s, value);
5883	return castState<FetchStartSet>();
5884	}
5885
5886	Builder<STATE \| DomainLookupStartSet>& setDomainLookupStart(double value)
5887	{
5888	COMPILE_ASSERT(!(STATE & DomainLookupStartSet), property_domainLookupStart_already_set);
5889	m_result ->setDouble("domainLookupStart"_s, value);
5890	return castState<DomainLookupStartSet>();
5891	}
5892
5893	Builder<STATE \| DomainLookupEndSet>& setDomainLookupEnd(double value)
5894	{
5895	COMPILE_ASSERT(!(STATE & DomainLookupEndSet), property_domainLookupEnd_already_set);
5896	m_result ->setDouble("domainLookupEnd"_s, value);
5897	return castState<DomainLookupEndSet>();
5898	}
5899
5900	Builder<STATE \| ConnectStartSet>& setConnectStart(double value)
5901	{
5902	COMPILE_ASSERT(!(STATE & ConnectStartSet), property_connectStart_already_set);
5903	m_result ->setDouble("connectStart"_s, value);
5904	return castState<ConnectStartSet>();
5905	}
5906
5907	Builder<STATE \| ConnectEndSet>& setConnectEnd(double value)
5908	{
5909	COMPILE_ASSERT(!(STATE & ConnectEndSet), property_connectEnd_already_set);
5910	m_result ->setDouble("connectEnd"_s, value);
5911	return castState<ConnectEndSet>();
5912	}
5913
5914	Builder<STATE \| SecureConnectionStartSet>& setSecureConnectionStart(double value)
5915	{
5916	COMPILE_ASSERT(!(STATE & SecureConnectionStartSet), property_secureConnectionStart_already_set);
5917	m_result ->setDouble("secureConnectionStart"_s, value);
5918	return castState<SecureConnectionStartSet>();
5919	}
5920
5921	Builder<STATE \| RequestStartSet>& setRequestStart(double value)
5922	{
5923	COMPILE_ASSERT(!(STATE & RequestStartSet), property_requestStart_already_set);
5924	m_result ->setDouble("requestStart"_s, value);
5925	return castState<RequestStartSet>();
5926	}
5927
5928	Builder<STATE \| ResponseStartSet>& setResponseStart(double value)
5929	{
5930	COMPILE_ASSERT(!(STATE & ResponseStartSet), property_responseStart_already_set);
5931	m_result ->setDouble("responseStart"_s, value);
5932	return castState<ResponseStartSet>();
5933	}
5934
5935	Builder<STATE \| ResponseEndSet>& setResponseEnd(double value)
5936	{
5937	COMPILE_ASSERT(!(STATE & ResponseEndSet), property_responseEnd_already_set);
5938	m_result ->setDouble("responseEnd"_s, value);
5939	return castState<ResponseEndSet>();
5940	}
5941
5942	Ref<ResourceTiming> release()
5943	{
5944	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5945	COMPILE_ASSERT(sizeof(ResourceTiming) == sizeof(JSON::Object), cannot_cast);
5946
5947	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5948	auto result = WTFMove(*reinterpret_cast<Ref<ResourceTiming>*>(&jsonResult));
5949	return result;
5950	}
5951	};
5952
5953	/*
5954	* Synthetic constructor:
5955	* Ref<ResourceTiming> result = ResourceTiming::create()
5956	* .setStartTime(...)
5957	* .setRedirectStart(...)
5958	* .setRedirectEnd(...)
5959	* .setFetchStart(...)
5960	* .setDomainLookupStart(...)
5961	* .setDomainLookupEnd(...)
5962	* .setConnectStart(...)
5963	* .setConnectEnd(...)
5964	* .setSecureConnectionStart(...)
5965	* .setRequestStart(...)
5966	* .setResponseStart(...)
5967	* .setResponseEnd(...)
5968	* .release();
5969	*/
5970	static Builder<NoFieldsSet> create()
5971	{
5972	return Builder<NoFieldsSet>(JSON::Object::create());
5973	}
5974	};
5975
5976	/ HTTP request data. /
5977	class Request : public JSON::ObjectBase {
5978	public:
5979	enum {
5980	NoFieldsSet = `0`,
5981	UrlSet = `1` << `0`,
5982	MethodSet = `1` << `1`,
5983	HeadersSet = `1` << `2`,
5984	AllFieldsSet = (UrlSet \| MethodSet \| HeadersSet)
5985	};
5986
5987	template<int STATE>
5988	class Builder {
5989	private:
5990	RefPtr<JSON::Object> m_result;
5991
5992	template<int STEP> Builder<STATE \| STEP>& castState()
5993	{
5994	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5995	}
5996
5997	Builder(Ref</Request/JSON::Object>&& object)
5998	: m_result (WTFMove(object))
5999	{
6000	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6001	}
6002	friend class Request;
6003	public:
6004
6005	Builder<STATE \| UrlSet>& setUrl(const String& value)
6006	{
6007	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6008	m_result ->setString("url"_s, value);
6009	return castState<UrlSet>();
6010	}
6011
6012	Builder<STATE \| MethodSet>& setMethod(const String& value)
6013	{
6014	COMPILE_ASSERT(!(STATE & MethodSet), property_method_already_set);
6015	m_result ->setString("method"_s, value);
6016	return castState<MethodSet>();
6017	}
6018
6019	Builder<STATE \| HeadersSet>& setHeaders(RefPtr<JSON::Object> value)
6020	{
6021	COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6022	m_result ->setObject("headers"_s, value);
6023	return castState<HeadersSet>();
6024	}
6025
6026	Ref<Request> release()
6027	{
6028	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6029	COMPILE_ASSERT(sizeof(Request) == sizeof(JSON::Object), cannot_cast);
6030
6031	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6032	auto result = WTFMove(*reinterpret_cast<Ref<Request>*>(&jsonResult));
6033	return result;
6034	}
6035	};
6036
6037	/*
6038	* Synthetic constructor:
6039	* Ref<Request> result = Request::create()
6040	* .setUrl(...)
6041	* .setMethod(...)
6042	* .setHeaders(...)
6043	* .release();
6044	*/
6045	static Builder<NoFieldsSet> create()
6046	{
6047	return Builder<NoFieldsSet>(JSON::Object::create());
6048	}
6049
6050	void setPostData(const String& value)
6051	{
6052	JSON::ObjectBase::setString("postData"_s, value);
6053	}
6054	};
6055
6056	/ HTTP response data. /
6057	class Response : public JSON::Object {
6058	public:
6059	// Named after property name 'source' while generating Response.
6060	enum class Source {
6061	Unknown = `115`,
6062	Network = `36`,
6063	MemoryCache = `116`,
6064	DiskCache = `117`,
6065	ServiceWorker = `118`,
6066	}; // enum class Source
6067	enum {
6068	NoFieldsSet = `0`,
6069	UrlSet = `1` << `0`,
6070	StatusSet = `1` << `1`,
6071	StatusTextSet = `1` << `2`,
6072	HeadersSet = `1` << `3`,
6073	MimeTypeSet = `1` << `4`,
6074	SourceSet = `1` << `5`,
6075	AllFieldsSet = (UrlSet \| StatusSet \| StatusTextSet \| HeadersSet \| MimeTypeSet \| SourceSet)
6076	};
6077
6078	template<int STATE>
6079	class Builder {
6080	private:
6081	RefPtr<JSON::Object> m_result;
6082
6083	template<int STEP> Builder<STATE \| STEP>& castState()
6084	{
6085	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6086	}
6087
6088	Builder(Ref</Response/JSON::Object>&& object)
6089	: m_result (WTFMove(object))
6090	{
6091	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6092	}
6093	friend class Response;
6094	public:
6095
6096	Builder<STATE \| UrlSet>& setUrl(const String& value)
6097	{
6098	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6099	m_result ->setString("url"_s, value);
6100	return castState<UrlSet>();
6101	}
6102
6103	Builder<STATE \| StatusSet>& setStatus(int value)
6104	{
6105	COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
6106	m_result ->setInteger("status"_s, value);
6107	return castState<StatusSet>();
6108	}
6109
6110	Builder<STATE \| StatusTextSet>& setStatusText(const String& value)
6111	{
6112	COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set);
6113	m_result ->setString("statusText"_s, value);
6114	return castState<StatusTextSet>();
6115	}
6116
6117	Builder<STATE \| HeadersSet>& setHeaders(RefPtr<JSON::Object> value)
6118	{
6119	COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6120	m_result ->setObject("headers"_s, value);
6121	return castState<HeadersSet>();
6122	}
6123
6124	Builder<STATE \| MimeTypeSet>& setMimeType(const String& value)
6125	{
6126	COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
6127	m_result ->setString("mimeType"_s, value);
6128	return castState<MimeTypeSet>();
6129	}
6130
6131	Builder<STATE \| SourceSet>& setSource(Source value)
6132	{
6133	COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
6134	m_result ->setString("source"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6135	return castState<SourceSet>();
6136	}
6137
6138	Ref<Response> release()
6139	{
6140	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6141	COMPILE_ASSERT(sizeof(Response) == sizeof(JSON::Object), cannot_cast);
6142
6143	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6144	auto result = WTFMove(*reinterpret_cast<Ref<Response>*>(&jsonResult));
6145	return result;
6146	}
6147	};
6148
6149	/*
6150	* Synthetic constructor:
6151	* Ref<Response> result = Response::create()
6152	* .setUrl(...)
6153	* .setStatus(...)
6154	* .setStatusText(...)
6155	* .setHeaders(...)
6156	* .setMimeType(...)
6157	* .setSource(...)
6158	* .release();
6159	*/
6160	static Builder<NoFieldsSet> create()
6161	{
6162	return Builder<NoFieldsSet>(JSON::Object::create());
6163	}
6164
6165	void setRequestHeaders(RefPtr<JSON::Object> value)
6166	{
6167	JSON::ObjectBase::setObject("requestHeaders"_s, WTFMove(value));
6168	}
6169
6170	void setTiming(RefPtr<Inspector::Protocol::Network::ResourceTiming> value)
6171	{
6172	JSON::ObjectBase::setObject("timing"_s, WTFMove(value));
6173	}
6174
6175	void setSecurity(RefPtr<Inspector::Protocol::Security::Security> value)
6176	{
6177	JSON::ObjectBase::setObject("security"_s, WTFMove(value));
6178	}
6179
6180	// Property names for type generated as open.
6181	JS_EXPORT_PRIVATE static const char* MimeType;
6182	};
6183
6184	/ Network load metrics. /
6185	class Metrics : public JSON::ObjectBase {
6186	public:
6187	// Named after property name 'priority' while generating Metrics.
6188	enum class Priority {
6189	Low = `119`,
6190	Medium = `120`,
6191	High = `121`,
6192	}; // enum class Priority
6193	enum {
6194	NoFieldsSet = `0`,
6195	AllFieldsSet = `0`
6196	};
6197
6198	template<int STATE>
6199	class Builder {
6200	private:
6201	RefPtr<JSON::Object> m_result;
6202
6203	template<int STEP> Builder<STATE \| STEP>& castState()
6204	{
6205	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6206	}
6207
6208	Builder(Ref</Metrics/JSON::Object>&& object)
6209	: m_result (WTFMove(object))
6210	{
6211	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6212	}
6213	friend class Metrics;
6214	public:
6215
6216	Ref<Metrics> release()
6217	{
6218	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6219	COMPILE_ASSERT(sizeof(Metrics) == sizeof(JSON::Object), cannot_cast);
6220
6221	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6222	auto result = WTFMove(*reinterpret_cast<Ref<Metrics>*>(&jsonResult));
6223	return result;
6224	}
6225	};
6226
6227	/*
6228	* Synthetic constructor:
6229	* Ref<Metrics> result = Metrics::create()
6230	* .release();
6231	*/
6232	static Builder<NoFieldsSet> create()
6233	{
6234	return Builder<NoFieldsSet>(JSON::Object::create());
6235	}
6236
6237	void setProtocol(const String& value)
6238	{
6239	JSON::ObjectBase::setString("protocol"_s, value);
6240	}
6241
6242	void setPriority(Priority value)
6243	{
6244	JSON::ObjectBase::setString("priority"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6245	}
6246
6247	void setConnectionIdentifier(const String& value)
6248	{
6249	JSON::ObjectBase::setString("connectionIdentifier"_s, value);
6250	}
6251
6252	void setRemoteAddress(const String& value)
6253	{
6254	JSON::ObjectBase::setString("remoteAddress"_s, value);
6255	}
6256
6257	void setRequestHeaders(RefPtr<JSON::Object> value)
6258	{
6259	JSON::ObjectBase::setObject("requestHeaders"_s, WTFMove(value));
6260	}
6261
6262	void setRequestHeaderBytesSent(double value)
6263	{
6264	JSON::ObjectBase::setDouble("requestHeaderBytesSent"_s, value);
6265	}
6266
6267	void setRequestBodyBytesSent(double value)
6268	{
6269	JSON::ObjectBase::setDouble("requestBodyBytesSent"_s, value);
6270	}
6271
6272	void setResponseHeaderBytesReceived(double value)
6273	{
6274	JSON::ObjectBase::setDouble("responseHeaderBytesReceived"_s, value);
6275	}
6276
6277	void setResponseBodyBytesReceived(double value)
6278	{
6279	JSON::ObjectBase::setDouble("responseBodyBytesReceived"_s, value);
6280	}
6281
6282	void setResponseBodyDecodedSize(double value)
6283	{
6284	JSON::ObjectBase::setDouble("responseBodyDecodedSize"_s, value);
6285	}
6286
6287	void setSecurityConnection(RefPtr<Inspector::Protocol::Security::Connection> value)
6288	{
6289	JSON::ObjectBase::setObject("securityConnection"_s, WTFMove(value));
6290	}
6291	};
6292
6293	/ WebSocket request data. /
6294	class WebSocketRequest : public JSON::ObjectBase {
6295	public:
6296	enum {
6297	NoFieldsSet = `0`,
6298	HeadersSet = `1` << `0`,
6299	AllFieldsSet = (HeadersSet)
6300	};
6301
6302	template<int STATE>
6303	class Builder {
6304	private:
6305	RefPtr<JSON::Object> m_result;
6306
6307	template<int STEP> Builder<STATE \| STEP>& castState()
6308	{
6309	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6310	}
6311
6312	Builder(Ref</WebSocketRequest/JSON::Object>&& object)
6313	: m_result (WTFMove(object))
6314	{
6315	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6316	}
6317	friend class WebSocketRequest;
6318	public:
6319
6320	Builder<STATE \| HeadersSet>& setHeaders(RefPtr<JSON::Object> value)
6321	{
6322	COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6323	m_result ->setObject("headers"_s, value);
6324	return castState<HeadersSet>();
6325	}
6326
6327	Ref<WebSocketRequest> release()
6328	{
6329	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6330	COMPILE_ASSERT(sizeof(WebSocketRequest) == sizeof(JSON::Object), cannot_cast);
6331
6332	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6333	auto result = WTFMove(*reinterpret_cast<Ref<WebSocketRequest>*>(&jsonResult));
6334	return result;
6335	}
6336	};
6337
6338	/*
6339	* Synthetic constructor:
6340	* Ref<WebSocketRequest> result = WebSocketRequest::create()
6341	* .setHeaders(...)
6342	* .release();
6343	*/
6344	static Builder<NoFieldsSet> create()
6345	{
6346	return Builder<NoFieldsSet>(JSON::Object::create());
6347	}
6348	};
6349
6350	/ WebSocket response data. /
6351	class WebSocketResponse : public JSON::ObjectBase {
6352	public:
6353	enum {
6354	NoFieldsSet = `0`,
6355	StatusSet = `1` << `0`,
6356	StatusTextSet = `1` << `1`,
6357	HeadersSet = `1` << `2`,
6358	AllFieldsSet = (StatusSet \| StatusTextSet \| HeadersSet)
6359	};
6360
6361	template<int STATE>
6362	class Builder {
6363	private:
6364	RefPtr<JSON::Object> m_result;
6365
6366	template<int STEP> Builder<STATE \| STEP>& castState()
6367	{
6368	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6369	}
6370
6371	Builder(Ref</WebSocketResponse/JSON::Object>&& object)
6372	: m_result (WTFMove(object))
6373	{
6374	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6375	}
6376	friend class WebSocketResponse;
6377	public:
6378
6379	Builder<STATE \| StatusSet>& setStatus(int value)
6380	{
6381	COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
6382	m_result ->setInteger("status"_s, value);
6383	return castState<StatusSet>();
6384	}
6385
6386	Builder<STATE \| StatusTextSet>& setStatusText(const String& value)
6387	{
6388	COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set);
6389	m_result ->setString("statusText"_s, value);
6390	return castState<StatusTextSet>();
6391	}
6392
6393	Builder<STATE \| HeadersSet>& setHeaders(RefPtr<JSON::Object> value)
6394	{
6395	COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6396	m_result ->setObject("headers"_s, value);
6397	return castState<HeadersSet>();
6398	}
6399
6400	Ref<WebSocketResponse> release()
6401	{
6402	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6403	COMPILE_ASSERT(sizeof(WebSocketResponse) == sizeof(JSON::Object), cannot_cast);
6404
6405	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6406	auto result = WTFMove(*reinterpret_cast<Ref<WebSocketResponse>*>(&jsonResult));
6407	return result;
6408	}
6409	};
6410
6411	/*
6412	* Synthetic constructor:
6413	* Ref<WebSocketResponse> result = WebSocketResponse::create()
6414	* .setStatus(...)
6415	* .setStatusText(...)
6416	* .setHeaders(...)
6417	* .release();
6418	*/
6419	static Builder<NoFieldsSet> create()
6420	{
6421	return Builder<NoFieldsSet>(JSON::Object::create());
6422	}
6423	};
6424
6425	/ WebSocket frame data. /
6426	class WebSocketFrame : public JSON::ObjectBase {
6427	public:
6428	enum {
6429	NoFieldsSet = `0`,
6430	OpcodeSet = `1` << `0`,
6431	MaskSet = `1` << `1`,
6432	PayloadDataSet = `1` << `2`,
6433	PayloadLengthSet = `1` << `3`,
6434	AllFieldsSet = (OpcodeSet \| MaskSet \| PayloadDataSet \| PayloadLengthSet)
6435	};
6436
6437	template<int STATE>
6438	class Builder {
6439	private:
6440	RefPtr<JSON::Object> m_result;
6441
6442	template<int STEP> Builder<STATE \| STEP>& castState()
6443	{
6444	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6445	}
6446
6447	Builder(Ref</WebSocketFrame/JSON::Object>&& object)
6448	: m_result (WTFMove(object))
6449	{
6450	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6451	}
6452	friend class WebSocketFrame;
6453	public:
6454
6455	Builder<STATE \| OpcodeSet>& setOpcode(double value)
6456	{
6457	COMPILE_ASSERT(!(STATE & OpcodeSet), property_opcode_already_set);
6458	m_result ->setDouble("opcode"_s, value);
6459	return castState<OpcodeSet>();
6460	}
6461
6462	Builder<STATE \| MaskSet>& setMask(bool value)
6463	{
6464	COMPILE_ASSERT(!(STATE & MaskSet), property_mask_already_set);
6465	m_result ->setBoolean("mask"_s, value);
6466	return castState<MaskSet>();
6467	}
6468
6469	Builder<STATE \| PayloadDataSet>& setPayloadData(const String& value)
6470	{
6471	COMPILE_ASSERT(!(STATE & PayloadDataSet), property_payloadData_already_set);
6472	m_result ->setString("payloadData"_s, value);
6473	return castState<PayloadDataSet>();
6474	}
6475
6476	Builder<STATE \| PayloadLengthSet>& setPayloadLength(double value)
6477	{
6478	COMPILE_ASSERT(!(STATE & PayloadLengthSet), property_payloadLength_already_set);
6479	m_result ->setDouble("payloadLength"_s, value);
6480	return castState<PayloadLengthSet>();
6481	}
6482
6483	Ref<WebSocketFrame> release()
6484	{
6485	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6486	COMPILE_ASSERT(sizeof(WebSocketFrame) == sizeof(JSON::Object), cannot_cast);
6487
6488	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6489	auto result = WTFMove(*reinterpret_cast<Ref<WebSocketFrame>*>(&jsonResult));
6490	return result;
6491	}
6492	};
6493
6494	/*
6495	* Synthetic constructor:
6496	* Ref<WebSocketFrame> result = WebSocketFrame::create()
6497	* .setOpcode(...)
6498	* .setMask(...)
6499	* .setPayloadData(...)
6500	* .setPayloadLength(...)
6501	* .release();
6502	*/
6503	static Builder<NoFieldsSet> create()
6504	{
6505	return Builder<NoFieldsSet>(JSON::Object::create());
6506	}
6507	};
6508
6509	/ Information about the cached resource. /
6510	class CachedResource : public JSON::ObjectBase {
6511	public:
6512	enum {
6513	NoFieldsSet = `0`,
6514	UrlSet = `1` << `0`,
6515	TypeSet = `1` << `1`,
6516	BodySizeSet = `1` << `2`,
6517	AllFieldsSet = (UrlSet \| TypeSet \| BodySizeSet)
6518	};
6519
6520	template<int STATE>
6521	class Builder {
6522	private:
6523	RefPtr<JSON::Object> m_result;
6524
6525	template<int STEP> Builder<STATE \| STEP>& castState()
6526	{
6527	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6528	}
6529
6530	Builder(Ref</CachedResource/JSON::Object>&& object)
6531	: m_result (WTFMove(object))
6532	{
6533	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6534	}
6535	friend class CachedResource;
6536	public:
6537
6538	Builder<STATE \| UrlSet>& setUrl(const String& value)
6539	{
6540	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6541	m_result ->setString("url"_s, value);
6542	return castState<UrlSet>();
6543	}
6544
6545	Builder<STATE \| TypeSet>& setType(Inspector::Protocol::Page::ResourceType value)
6546	{
6547	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6548	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6549	return castState<TypeSet>();
6550	}
6551
6552	Builder<STATE \| BodySizeSet>& setBodySize(double value)
6553	{
6554	COMPILE_ASSERT(!(STATE & BodySizeSet), property_bodySize_already_set);
6555	m_result ->setDouble("bodySize"_s, value);
6556	return castState<BodySizeSet>();
6557	}
6558
6559	Ref<CachedResource> release()
6560	{
6561	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6562	COMPILE_ASSERT(sizeof(CachedResource) == sizeof(JSON::Object), cannot_cast);
6563
6564	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6565	auto result = WTFMove(*reinterpret_cast<Ref<CachedResource>*>(&jsonResult));
6566	return result;
6567	}
6568	};
6569
6570	/*
6571	* Synthetic constructor:
6572	* Ref<CachedResource> result = CachedResource::create()
6573	* .setUrl(...)
6574	* .setType(...)
6575	* .setBodySize(...)
6576	* .release();
6577	*/
6578	static Builder<NoFieldsSet> create()
6579	{
6580	return Builder<NoFieldsSet>(JSON::Object::create());
6581	}
6582
6583	void setResponse(RefPtr<Inspector::Protocol::Network::Response> value)
6584	{
6585	JSON::ObjectBase::setObject("response"_s, WTFMove(value));
6586	}
6587
6588	void setSourceMapURL(const String& value)
6589	{
6590	JSON::ObjectBase::setString("sourceMapURL"_s, value);
6591	}
6592	};
6593
6594	/ Information about the request initiator. /
6595	class Initiator : public JSON::ObjectBase {
6596	public:
6597	// Named after property name 'type' while generating Initiator.
6598	enum class Type {
6599	Parser = `133`,
6600	Script = `134`,
6601	Other = `47`,
6602	}; // enum class Type
6603	enum {
6604	NoFieldsSet = `0`,
6605	TypeSet = `1` << `0`,
6606	AllFieldsSet = (TypeSet)
6607	};
6608
6609	template<int STATE>
6610	class Builder {
6611	private:
6612	RefPtr<JSON::Object> m_result;
6613
6614	template<int STEP> Builder<STATE \| STEP>& castState()
6615	{
6616	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6617	}
6618
6619	Builder(Ref</Initiator/JSON::Object>&& object)
6620	: m_result (WTFMove(object))
6621	{
6622	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6623	}
6624	friend class Initiator;
6625	public:
6626
6627	Builder<STATE \| TypeSet>& setType(Type value)
6628	{
6629	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6630	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6631	return castState<TypeSet>();
6632	}
6633
6634	Ref<Initiator> release()
6635	{
6636	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6637	COMPILE_ASSERT(sizeof(Initiator) == sizeof(JSON::Object), cannot_cast);
6638
6639	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6640	auto result = WTFMove(*reinterpret_cast<Ref<Initiator>*>(&jsonResult));
6641	return result;
6642	}
6643	};
6644
6645	/*
6646	* Synthetic constructor:
6647	* Ref<Initiator> result = Initiator::create()
6648	* .setType(...)
6649	* .release();
6650	*/
6651	static Builder<NoFieldsSet> create()
6652	{
6653	return Builder<NoFieldsSet>(JSON::Object::create());
6654	}
6655
6656	void setStackTrace(RefPtr<JSON::ArrayOf<Inspector::Protocol::Console::CallFrame>> value)
6657	{
6658	JSON::ObjectBase::setArray("stackTrace"_s, WTFMove(value));
6659	}
6660
6661	void setUrl(const String& value)
6662	{
6663	JSON::ObjectBase::setString("url"_s, value);
6664	}
6665
6666	void setLineNumber(double value)
6667	{
6668	JSON::ObjectBase::setDouble("lineNumber"_s, value);
6669	}
6670
6671	void setNodeId(int value)
6672	{
6673	JSON::ObjectBase::setInteger("nodeId"_s, value);
6674	}
6675	};
6676
6677	} // Network
6678
6679	namespace Page {
6680	/ List of settings able to be overridden by WebInspector. Keep this in sync with FOR_EACH_INSPECTOR_OVERRIDE_SETTING. /
6681	enum class Setting {
6682	AuthorAndUserStylesEnabled = `135`,
6683	ICECandidateFilteringEnabled = `136`,
6684	ImagesEnabled = `137`,
6685	MediaCaptureRequiresSecureConnection = `138`,
6686	MockCaptureDevicesEnabled = `139`,
6687	NeedsSiteSpecificQuirks = `140`,
6688	ScriptEnabled = `141`,
6689	WebSecurityEnabled = `142`,
6690	}; // enum class Setting
6691	/ Resource type as it was perceived by the rendering engine. /
6692	enum class ResourceType {
6693	Document = `122`,
6694	Stylesheet = `123`,
6695	Image = `124`,
6696	Font = `125`,
6697	Script = `126`,
6698	XHR = `127`,
6699	Fetch = `128`,
6700	Ping = `129`,
6701	Beacon = `130`,
6702	WebSocket = `131`,
6703	Other = `132`,
6704	}; // enum class ResourceType
6705	/ Coordinate system used by supplied coordinates. /
6706	enum class CoordinateSystem {
6707	Viewport = `143`,
6708	Page = `144`,
6709	}; // enum class CoordinateSystem
6710	/ Same-Site policy of a cookie. /
6711	enum class CookieSameSitePolicy {
6712	None = `145`,
6713	Lax = `146`,
6714	Strict = `147`,
6715	}; // enum class CookieSameSitePolicy
6716	/ Page appearance name. /
6717	enum class Appearance {
6718	Light = `148`,
6719	Dark = `149`,
6720	}; // enum class Appearance
6721	/ Information about the Frame on the page. /
6722	class Frame : public JSON::ObjectBase {
6723	public:
6724	enum {
6725	NoFieldsSet = `0`,
6726	IdSet = `1` << `0`,
6727	LoaderIdSet = `1` << `1`,
6728	UrlSet = `1` << `2`,
6729	SecurityOriginSet = `1` << `3`,
6730	MimeTypeSet = `1` << `4`,
6731	AllFieldsSet = (IdSet \| LoaderIdSet \| UrlSet \| SecurityOriginSet \| MimeTypeSet)
6732	};
6733
6734	template<int STATE>
6735	class Builder {
6736	private:
6737	RefPtr<JSON::Object> m_result;
6738
6739	template<int STEP> Builder<STATE \| STEP>& castState()
6740	{
6741	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6742	}
6743
6744	Builder(Ref</Frame/JSON::Object>&& object)
6745	: m_result (WTFMove(object))
6746	{
6747	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6748	}
6749	friend class Frame;
6750	public:
6751
6752	Builder<STATE \| IdSet>& setId(const String& value)
6753	{
6754	COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
6755	m_result ->setString("id"_s, value);
6756	return castState<IdSet>();
6757	}
6758
6759	Builder<STATE \| LoaderIdSet>& setLoaderId(const String& value)
6760	{
6761	COMPILE_ASSERT(!(STATE & LoaderIdSet), property_loaderId_already_set);
6762	m_result ->setString("loaderId"_s, value);
6763	return castState<LoaderIdSet>();
6764	}
6765
6766	Builder<STATE \| UrlSet>& setUrl(const String& value)
6767	{
6768	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6769	m_result ->setString("url"_s, value);
6770	return castState<UrlSet>();
6771	}
6772
6773	Builder<STATE \| SecurityOriginSet>& setSecurityOrigin(const String& value)
6774	{
6775	COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
6776	m_result ->setString("securityOrigin"_s, value);
6777	return castState<SecurityOriginSet>();
6778	}
6779
6780	Builder<STATE \| MimeTypeSet>& setMimeType(const String& value)
6781	{
6782	COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
6783	m_result ->setString("mimeType"_s, value);
6784	return castState<MimeTypeSet>();
6785	}
6786
6787	Ref<Frame> release()
6788	{
6789	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6790	COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast);
6791
6792	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6793	auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult));
6794	return result;
6795	}
6796	};
6797
6798	/*
6799	* Synthetic constructor:
6800	* Ref<Frame> result = Frame::create()
6801	* .setId(...)
6802	* .setLoaderId(...)
6803	* .setUrl(...)
6804	* .setSecurityOrigin(...)
6805	* .setMimeType(...)
6806	* .release();
6807	*/
6808	static Builder<NoFieldsSet> create()
6809	{
6810	return Builder<NoFieldsSet>(JSON::Object::create());
6811	}
6812
6813	void setParentId(const String& value)
6814	{
6815	JSON::ObjectBase::setString("parentId"_s, value);
6816	}
6817
6818	void setName(const String& value)
6819	{
6820	JSON::ObjectBase::setString("name"_s, value);
6821	}
6822	};
6823
6824	class FrameResource : public JSON::ObjectBase {
6825	public:
6826	enum {
6827	NoFieldsSet = `0`,
6828	UrlSet = `1` << `0`,
6829	TypeSet = `1` << `1`,
6830	MimeTypeSet = `1` << `2`,
6831	AllFieldsSet = (UrlSet \| TypeSet \| MimeTypeSet)
6832	};
6833
6834	template<int STATE>
6835	class Builder {
6836	private:
6837	RefPtr<JSON::Object> m_result;
6838
6839	template<int STEP> Builder<STATE \| STEP>& castState()
6840	{
6841	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6842	}
6843
6844	Builder(Ref</FrameResource/JSON::Object>&& object)
6845	: m_result (WTFMove(object))
6846	{
6847	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6848	}
6849	friend class FrameResource;
6850	public:
6851
6852	Builder<STATE \| UrlSet>& setUrl(const String& value)
6853	{
6854	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6855	m_result ->setString("url"_s, value);
6856	return castState<UrlSet>();
6857	}
6858
6859	Builder<STATE \| TypeSet>& setType(Inspector::Protocol::Page::ResourceType value)
6860	{
6861	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6862	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6863	return castState<TypeSet>();
6864	}
6865
6866	Builder<STATE \| MimeTypeSet>& setMimeType(const String& value)
6867	{
6868	COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
6869	m_result ->setString("mimeType"_s, value);
6870	return castState<MimeTypeSet>();
6871	}
6872
6873	Ref<FrameResource> release()
6874	{
6875	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6876	COMPILE_ASSERT(sizeof(FrameResource) == sizeof(JSON::Object), cannot_cast);
6877
6878	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6879	auto result = WTFMove(*reinterpret_cast<Ref<FrameResource>*>(&jsonResult));
6880	return result;
6881	}
6882	};
6883
6884	/*
6885	* Synthetic constructor:
6886	* Ref<FrameResource> result = FrameResource::create()
6887	* .setUrl(...)
6888	* .setType(...)
6889	* .setMimeType(...)
6890	* .release();
6891	*/
6892	static Builder<NoFieldsSet> create()
6893	{
6894	return Builder<NoFieldsSet>(JSON::Object::create());
6895	}
6896
6897	void setFailed(bool value)
6898	{
6899	JSON::ObjectBase::setBoolean("failed"_s, value);
6900	}
6901
6902	void setCanceled(bool value)
6903	{
6904	JSON::ObjectBase::setBoolean("canceled"_s, value);
6905	}
6906
6907	void setSourceMapURL(const String& value)
6908	{
6909	JSON::ObjectBase::setString("sourceMapURL"_s, value);
6910	}
6911
6912	void setTargetId(const String& value)
6913	{
6914	JSON::ObjectBase::setString("targetId"_s, value);
6915	}
6916	};
6917
6918	/ Information about the Frame hierarchy along with their cached resources. /
6919	class FrameResourceTree : public JSON::ObjectBase {
6920	public:
6921	enum {
6922	NoFieldsSet = `0`,
6923	FrameSet = `1` << `0`,
6924	ResourcesSet = `1` << `1`,
6925	AllFieldsSet = (FrameSet \| ResourcesSet)
6926	};
6927
6928	template<int STATE>
6929	class Builder {
6930	private:
6931	RefPtr<JSON::Object> m_result;
6932
6933	template<int STEP> Builder<STATE \| STEP>& castState()
6934	{
6935	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6936	}
6937
6938	Builder(Ref</FrameResourceTree/JSON::Object>&& object)
6939	: m_result (WTFMove(object))
6940	{
6941	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6942	}
6943	friend class FrameResourceTree;
6944	public:
6945
6946	Builder<STATE \| FrameSet>& setFrame(RefPtr<Inspector::Protocol::Page::Frame> value)
6947	{
6948	COMPILE_ASSERT(!(STATE & FrameSet), property_frame_already_set);
6949	m_result ->setObject("frame"_s, value);
6950	return castState<FrameSet>();
6951	}
6952
6953	Builder<STATE \| ResourcesSet>& setResources(RefPtr<JSON::ArrayOf<Inspector::Protocol::Page::FrameResource>> value)
6954	{
6955	COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set);
6956	m_result ->setArray("resources"_s, value);
6957	return castState<ResourcesSet>();
6958	}
6959
6960	Ref<FrameResourceTree> release()
6961	{
6962	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6963	COMPILE_ASSERT(sizeof(FrameResourceTree) == sizeof(JSON::Object), cannot_cast);
6964
6965	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6966	auto result = WTFMove(*reinterpret_cast<Ref<FrameResourceTree>*>(&jsonResult));
6967	return result;
6968	}
6969	};
6970
6971	/*
6972	* Synthetic constructor:
6973	* Ref<FrameResourceTree> result = FrameResourceTree::create()
6974	* .setFrame(...)
6975	* .setResources(...)
6976	* .release();
6977	*/
6978	static Builder<NoFieldsSet> create()
6979	{
6980	return Builder<NoFieldsSet>(JSON::Object::create());
6981	}
6982
6983	void setChildFrames(RefPtr<JSON::ArrayOf<Inspector::Protocol::Page::FrameResourceTree>> value)
6984	{
6985	JSON::ObjectBase::setArray("childFrames"_s, WTFMove(value));
6986	}
6987	};
6988
6989	/ Search result for resource. /
6990	class SearchResult : public JSON::ObjectBase {
6991	public:
6992	enum {
6993	NoFieldsSet = `0`,
6994	UrlSet = `1` << `0`,
6995	FrameIdSet = `1` << `1`,
6996	MatchesCountSet = `1` << `2`,
6997	AllFieldsSet = (UrlSet \| FrameIdSet \| MatchesCountSet)
6998	};
6999
7000	template<int STATE>
7001	class Builder {
7002	private:
7003	RefPtr<JSON::Object> m_result;
7004
7005	template<int STEP> Builder<STATE \| STEP>& castState()
7006	{
7007	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7008	}
7009
7010	Builder(Ref</SearchResult/JSON::Object>&& object)
7011	: m_result (WTFMove(object))
7012	{
7013	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7014	}
7015	friend class SearchResult;
7016	public:
7017
7018	Builder<STATE \| UrlSet>& setUrl(const String& value)
7019	{
7020	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7021	m_result ->setString("url"_s, value);
7022	return castState<UrlSet>();
7023	}
7024
7025	Builder<STATE \| FrameIdSet>& setFrameId(const String& value)
7026	{
7027	COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
7028	m_result ->setString("frameId"_s, value);
7029	return castState<FrameIdSet>();
7030	}
7031
7032	Builder<STATE \| MatchesCountSet>& setMatchesCount(double value)
7033	{
7034	COMPILE_ASSERT(!(STATE & MatchesCountSet), property_matchesCount_already_set);
7035	m_result ->setDouble("matchesCount"_s, value);
7036	return castState<MatchesCountSet>();
7037	}
7038
7039	Ref<SearchResult> release()
7040	{
7041	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7042	COMPILE_ASSERT(sizeof(SearchResult) == sizeof(JSON::Object), cannot_cast);
7043
7044	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7045	auto result = WTFMove(*reinterpret_cast<Ref<SearchResult>*>(&jsonResult));
7046	return result;
7047	}
7048	};
7049
7050	/*
7051	* Synthetic constructor:
7052	* Ref<SearchResult> result = SearchResult::create()
7053	* .setUrl(...)
7054	* .setFrameId(...)
7055	* .setMatchesCount(...)
7056	* .release();
7057	*/
7058	static Builder<NoFieldsSet> create()
7059	{
7060	return Builder<NoFieldsSet>(JSON::Object::create());
7061	}
7062
7063	void setRequestId(const String& value)
7064	{
7065	JSON::ObjectBase::setString("requestId"_s, value);
7066	}
7067	};
7068
7069	/ Cookie object /
7070	class Cookie : public JSON::ObjectBase {
7071	public:
7072	enum {
7073	NoFieldsSet = `0`,
7074	NameSet = `1` << `0`,
7075	ValueSet = `1` << `1`,
7076	DomainSet = `1` << `2`,
7077	PathSet = `1` << `3`,
7078	ExpiresSet = `1` << `4`,
7079	SizeSet = `1` << `5`,
7080	HttpOnlySet = `1` << `6`,
7081	SecureSet = `1` << `7`,
7082	SessionSet = `1` << `8`,
7083	SameSiteSet = `1` << `9`,
7084	AllFieldsSet = (NameSet \| ValueSet \| DomainSet \| PathSet \| ExpiresSet \| SizeSet \| HttpOnlySet \| SecureSet \| SessionSet \| SameSiteSet)
7085	};
7086
7087	template<int STATE>
7088	class Builder {
7089	private:
7090	RefPtr<JSON::Object> m_result;
7091
7092	template<int STEP> Builder<STATE \| STEP>& castState()
7093	{
7094	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7095	}
7096
7097	Builder(Ref</Cookie/JSON::Object>&& object)
7098	: m_result (WTFMove(object))
7099	{
7100	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7101	}
7102	friend class Cookie;
7103	public:
7104
7105	Builder<STATE \| NameSet>& setName(const String& value)
7106	{
7107	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
7108	m_result ->setString("name"_s, value);
7109	return castState<NameSet>();
7110	}
7111
7112	Builder<STATE \| ValueSet>& setValue(const String& value)
7113	{
7114	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
7115	m_result ->setString("value"_s, value);
7116	return castState<ValueSet>();
7117	}
7118
7119	Builder<STATE \| DomainSet>& setDomain(const String& value)
7120	{
7121	COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set);
7122	m_result ->setString("domain"_s, value);
7123	return castState<DomainSet>();
7124	}
7125
7126	Builder<STATE \| PathSet>& setPath(const String& value)
7127	{
7128	COMPILE_ASSERT(!(STATE & PathSet), property_path_already_set);
7129	m_result ->setString("path"_s, value);
7130	return castState<PathSet>();
7131	}
7132
7133	Builder<STATE \| ExpiresSet>& setExpires(double value)
7134	{
7135	COMPILE_ASSERT(!(STATE & ExpiresSet), property_expires_already_set);
7136	m_result ->setDouble("expires"_s, value);
7137	return castState<ExpiresSet>();
7138	}
7139
7140	Builder<STATE \| SizeSet>& setSize(int value)
7141	{
7142	COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
7143	m_result ->setInteger("size"_s, value);
7144	return castState<SizeSet>();
7145	}
7146
7147	Builder<STATE \| HttpOnlySet>& setHttpOnly(bool value)
7148	{
7149	COMPILE_ASSERT(!(STATE & HttpOnlySet), property_httpOnly_already_set);
7150	m_result ->setBoolean("httpOnly"_s, value);
7151	return castState<HttpOnlySet>();
7152	}
7153
7154	Builder<STATE \| SecureSet>& setSecure(bool value)
7155	{
7156	COMPILE_ASSERT(!(STATE & SecureSet), property_secure_already_set);
7157	m_result ->setBoolean("secure"_s, value);
7158	return castState<SecureSet>();
7159	}
7160
7161	Builder<STATE \| SessionSet>& setSession(bool value)
7162	{
7163	COMPILE_ASSERT(!(STATE & SessionSet), property_session_already_set);
7164	m_result ->setBoolean("session"_s, value);
7165	return castState<SessionSet>();
7166	}
7167
7168	Builder<STATE \| SameSiteSet>& setSameSite(Inspector::Protocol::Page::CookieSameSitePolicy value)
7169	{
7170	COMPILE_ASSERT(!(STATE & SameSiteSet), property_sameSite_already_set);
7171	m_result ->setString("sameSite"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7172	return castState<SameSiteSet>();
7173	}
7174
7175	Ref<Cookie> release()
7176	{
7177	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7178	COMPILE_ASSERT(sizeof(Cookie) == sizeof(JSON::Object), cannot_cast);
7179
7180	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7181	auto result = WTFMove(*reinterpret_cast<Ref<Cookie>*>(&jsonResult));
7182	return result;
7183	}
7184	};
7185
7186	/*
7187	* Synthetic constructor:
7188	* Ref<Cookie> result = Cookie::create()
7189	* .setName(...)
7190	* .setValue(...)
7191	* .setDomain(...)
7192	* .setPath(...)
7193	* .setExpires(...)
7194	* .setSize(...)
7195	* .setHttpOnly(...)
7196	* .setSecure(...)
7197	* .setSession(...)
7198	* .setSameSite(...)
7199	* .release();
7200	*/
7201	static Builder<NoFieldsSet> create()
7202	{
7203	return Builder<NoFieldsSet>(JSON::Object::create());
7204	}
7205	};
7206
7207	} // Page
7208
7209	namespace Recording {
7210	/ The type of the recording. /
7211	enum class Type {
7212	Canvas2D = `27`,
7213	CanvasBitmapRenderer = `150`,
7214	CanvasWebGL = `151`,
7215	CanvasWebGL2 = `152`,
7216	}; // enum class Type
7217	/ /
7218	enum class Initiator {
7219	Frontend = `153`,
7220	Console = `154`,
7221	AutoCapture = `155`,
7222	}; // enum class Initiator
7223	/ Information about the initial state of the recorded object. /
7224	class InitialState : public JSON::ObjectBase {
7225	public:
7226	enum {
7227	NoFieldsSet = `0`,
7228	AllFieldsSet = `0`
7229	};
7230
7231	template<int STATE>
7232	class Builder {
7233	private:
7234	RefPtr<JSON::Object> m_result;
7235
7236	template<int STEP> Builder<STATE \| STEP>& castState()
7237	{
7238	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7239	}
7240
7241	Builder(Ref</InitialState/JSON::Object>&& object)
7242	: m_result (WTFMove(object))
7243	{
7244	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7245	}
7246	friend class InitialState;
7247	public:
7248
7249	Ref<InitialState> release()
7250	{
7251	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7252	COMPILE_ASSERT(sizeof(InitialState) == sizeof(JSON::Object), cannot_cast);
7253
7254	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7255	auto result = WTFMove(*reinterpret_cast<Ref<InitialState>*>(&jsonResult));
7256	return result;
7257	}
7258	};
7259
7260	/*
7261	* Synthetic constructor:
7262	* Ref<InitialState> result = InitialState::create()
7263	* .release();
7264	*/
7265	static Builder<NoFieldsSet> create()
7266	{
7267	return Builder<NoFieldsSet>(JSON::Object::create());
7268	}
7269
7270	void setAttributes(RefPtr<JSON::Object> value)
7271	{
7272	JSON::ObjectBase::setObject("attributes"_s, WTFMove(value));
7273	}
7274
7275	void setStates(RefPtr<JSON::ArrayOf<JSON::Object>> value)
7276	{
7277	JSON::ObjectBase::setArray("states"_s, WTFMove(value));
7278	}
7279
7280	void setParameters(RefPtr<JSON::ArrayOf<JSON::Value>> value)
7281	{
7282	JSON::ObjectBase::setArray("parameters"_s, WTFMove(value));
7283	}
7284
7285	void setContent(const String& value)
7286	{
7287	JSON::ObjectBase::setString("content"_s, value);
7288	}
7289	};
7290
7291	/ Container object for a single frame of the recording. /
7292	class Frame : public JSON::ObjectBase {
7293	public:
7294	enum {
7295	NoFieldsSet = `0`,
7296	ActionsSet = `1` << `0`,
7297	AllFieldsSet = (ActionsSet)
7298	};
7299
7300	template<int STATE>
7301	class Builder {
7302	private:
7303	RefPtr<JSON::Object> m_result;
7304
7305	template<int STEP> Builder<STATE \| STEP>& castState()
7306	{
7307	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7308	}
7309
7310	Builder(Ref</Frame/JSON::Object>&& object)
7311	: m_result (WTFMove(object))
7312	{
7313	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7314	}
7315	friend class Frame;
7316	public:
7317
7318	Builder<STATE \| ActionsSet>& setActions(RefPtr<JSON::ArrayOf<JSON::Value>> value)
7319	{
7320	COMPILE_ASSERT(!(STATE & ActionsSet), property_actions_already_set);
7321	m_result ->setArray("actions"_s, value);
7322	return castState<ActionsSet>();
7323	}
7324
7325	Ref<Frame> release()
7326	{
7327	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7328	COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast);
7329
7330	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7331	auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult));
7332	return result;
7333	}
7334	};
7335
7336	/*
7337	* Synthetic constructor:
7338	* Ref<Frame> result = Frame::create()
7339	* .setActions(...)
7340	* .release();
7341	*/
7342	static Builder<NoFieldsSet> create()
7343	{
7344	return Builder<NoFieldsSet>(JSON::Object::create());
7345	}
7346
7347	void setDuration(double value)
7348	{
7349	JSON::ObjectBase::setDouble("duration"_s, value);
7350	}
7351
7352	void setIncomplete(bool value)
7353	{
7354	JSON::ObjectBase::setBoolean("incomplete"_s, value);
7355	}
7356	};
7357
7358	class Recording : public JSON::ObjectBase {
7359	public:
7360	enum {
7361	NoFieldsSet = `0`,
7362	VersionSet = `1` << `0`,
7363	TypeSet = `1` << `1`,
7364	InitialStateSet = `1` << `2`,
7365	DataSet = `1` << `3`,
7366	AllFieldsSet = (VersionSet \| TypeSet \| InitialStateSet \| DataSet)
7367	};
7368
7369	template<int STATE>
7370	class Builder {
7371	private:
7372	RefPtr<JSON::Object> m_result;
7373
7374	template<int STEP> Builder<STATE \| STEP>& castState()
7375	{
7376	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7377	}
7378
7379	Builder(Ref</Recording/JSON::Object>&& object)
7380	: m_result (WTFMove(object))
7381	{
7382	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7383	}
7384	friend class Recording;
7385	public:
7386
7387	Builder<STATE \| VersionSet>& setVersion(int value)
7388	{
7389	COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
7390	m_result ->setInteger("version"_s, value);
7391	return castState<VersionSet>();
7392	}
7393
7394	Builder<STATE \| TypeSet>& setType(Inspector::Protocol::Recording::Type value)
7395	{
7396	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7397	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7398	return castState<TypeSet>();
7399	}
7400
7401	Builder<STATE \| InitialStateSet>& setInitialState(RefPtr<Inspector::Protocol::Recording::InitialState> value)
7402	{
7403	COMPILE_ASSERT(!(STATE & InitialStateSet), property_initialState_already_set);
7404	m_result ->setObject("initialState"_s, value);
7405	return castState<InitialStateSet>();
7406	}
7407
7408	Builder<STATE \| DataSet>& setData(RefPtr<JSON::ArrayOf<JSON::Value>> value)
7409	{
7410	COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set);
7411	m_result ->setArray("data"_s, value);
7412	return castState<DataSet>();
7413	}
7414
7415	Ref<Recording> release()
7416	{
7417	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7418	COMPILE_ASSERT(sizeof(Recording) == sizeof(JSON::Object), cannot_cast);
7419
7420	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7421	auto result = WTFMove(*reinterpret_cast<Ref<Recording>*>(&jsonResult));
7422	return result;
7423	}
7424	};
7425
7426	/*
7427	* Synthetic constructor:
7428	* Ref<Recording> result = Recording::create()
7429	* .setVersion(...)
7430	* .setType(...)
7431	* .setInitialState(...)
7432	* .setData(...)
7433	* .release();
7434	*/
7435	static Builder<NoFieldsSet> create()
7436	{
7437	return Builder<NoFieldsSet>(JSON::Object::create());
7438	}
7439
7440	void setName(const String& value)
7441	{
7442	JSON::ObjectBase::setString("name"_s, value);
7443	}
7444	};
7445
7446	} // Recording
7447
7448	namespace Runtime {
7449	/ Mirror object referencing original JavaScript object. /
7450	class RemoteObject : public JSON::ObjectBase {
7451	public:
7452	// Named after property name 'type' while generating RemoteObject.
7453	enum class Type {
7454	Object = `156`,
7455	Function = `157`,
7456	Undefined = `158`,
7457	String = `109`,
7458	Number = `108`,
7459	Boolean = `159`,
7460	Symbol = `160`,
7461	}; // enum class Type
7462	// Named after property name 'subtype' while generating RemoteObject.
7463	enum class Subtype {
7464	Array = `110`,
7465	Null = `111`,
7466	Node = `161`,
7467	Regexp = `162`,
7468	Date = `84`,
7469	Error = `54`,
7470	Map = `163`,
7471	Set = `164`,
7472	Weakmap = `165`,
7473	Weakset = `166`,
7474	Iterator = `167`,
7475	Class = `168`,
7476	Proxy = `169`,
7477	}; // enum class Subtype
7478	enum {
7479	NoFieldsSet = `0`,
7480	TypeSet = `1` << `0`,
7481	AllFieldsSet = (TypeSet)
7482	};
7483
7484	template<int STATE>
7485	class Builder {
7486	private:
7487	RefPtr<JSON::Object> m_result;
7488
7489	template<int STEP> Builder<STATE \| STEP>& castState()
7490	{
7491	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7492	}
7493
7494	Builder(Ref</RemoteObject/JSON::Object>&& object)
7495	: m_result (WTFMove(object))
7496	{
7497	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7498	}
7499	friend class RemoteObject;
7500	public:
7501
7502	Builder<STATE \| TypeSet>& setType(Type value)
7503	{
7504	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7505	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7506	return castState<TypeSet>();
7507	}
7508
7509	Ref<RemoteObject> release()
7510	{
7511	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7512	COMPILE_ASSERT(sizeof(RemoteObject) == sizeof(JSON::Object), cannot_cast);
7513
7514	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7515	auto result = WTFMove(*reinterpret_cast<Ref<RemoteObject>*>(&jsonResult));
7516	return result;
7517	}
7518	};
7519
7520	/*
7521	* Synthetic constructor:
7522	* Ref<RemoteObject> result = RemoteObject::create()
7523	* .setType(...)
7524	* .release();
7525	*/
7526	static Builder<NoFieldsSet> create()
7527	{
7528	return Builder<NoFieldsSet>(JSON::Object::create());
7529	}
7530
7531	void setSubtype(Subtype value)
7532	{
7533	JSON::ObjectBase::setString("subtype"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7534	}
7535
7536	void setClassName(const String& value)
7537	{
7538	JSON::ObjectBase::setString("className"_s, value);
7539	}
7540
7541	void setValue(RefPtr<JSON::Value> value)
7542	{
7543	JSON::ObjectBase::setValue("value"_s, WTFMove(value));
7544	}
7545
7546	void setDescription(const String& value)
7547	{
7548	JSON::ObjectBase::setString("description"_s, value);
7549	}
7550
7551	void setObjectId(const String& value)
7552	{
7553	JSON::ObjectBase::setString("objectId"_s, value);
7554	}
7555
7556	void setSize(int value)
7557	{
7558	JSON::ObjectBase::setInteger("size"_s, value);
7559	}
7560
7561	void setClassPrototype(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7562	{
7563	JSON::ObjectBase::setObject("classPrototype"_s, WTFMove(value));
7564	}
7565
7566	void setPreview(RefPtr<Inspector::Protocol::Runtime::ObjectPreview> value)
7567	{
7568	JSON::ObjectBase::setObject("preview"_s, WTFMove(value));
7569	}
7570	};
7571
7572	/ Object containing abbreviated remote object value. /
7573	class ObjectPreview : public JSON::ObjectBase {
7574	public:
7575	// Named after property name 'type' while generating ObjectPreview.
7576	enum class Type {
7577	Object = `156`,
7578	Function = `157`,
7579	Undefined = `158`,
7580	String = `109`,
7581	Number = `108`,
7582	Boolean = `159`,
7583	Symbol = `160`,
7584	}; // enum class Type
7585	// Named after property name 'subtype' while generating ObjectPreview.
7586	enum class Subtype {
7587	Array = `110`,
7588	Null = `111`,
7589	Node = `161`,
7590	Regexp = `162`,
7591	Date = `84`,
7592	Error = `54`,
7593	Map = `163`,
7594	Set = `164`,
7595	Weakmap = `165`,
7596	Weakset = `166`,
7597	Iterator = `167`,
7598	Class = `168`,
7599	Proxy = `169`,
7600	}; // enum class Subtype
7601	enum {
7602	NoFieldsSet = `0`,
7603	TypeSet = `1` << `0`,
7604	LosslessSet = `1` << `1`,
7605	AllFieldsSet = (TypeSet \| LosslessSet)
7606	};
7607
7608	template<int STATE>
7609	class Builder {
7610	private:
7611	RefPtr<JSON::Object> m_result;
7612
7613	template<int STEP> Builder<STATE \| STEP>& castState()
7614	{
7615	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7616	}
7617
7618	Builder(Ref</ObjectPreview/JSON::Object>&& object)
7619	: m_result (WTFMove(object))
7620	{
7621	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7622	}
7623	friend class ObjectPreview;
7624	public:
7625
7626	Builder<STATE \| TypeSet>& setType(Type value)
7627	{
7628	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7629	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7630	return castState<TypeSet>();
7631	}
7632
7633	Builder<STATE \| LosslessSet>& setLossless(bool value)
7634	{
7635	COMPILE_ASSERT(!(STATE & LosslessSet), property_lossless_already_set);
7636	m_result ->setBoolean("lossless"_s, value);
7637	return castState<LosslessSet>();
7638	}
7639
7640	Ref<ObjectPreview> release()
7641	{
7642	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7643	COMPILE_ASSERT(sizeof(ObjectPreview) == sizeof(JSON::Object), cannot_cast);
7644
7645	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7646	auto result = WTFMove(*reinterpret_cast<Ref<ObjectPreview>*>(&jsonResult));
7647	return result;
7648	}
7649	};
7650
7651	/*
7652	* Synthetic constructor:
7653	* Ref<ObjectPreview> result = ObjectPreview::create()
7654	* .setType(...)
7655	* .setLossless(...)
7656	* .release();
7657	*/
7658	static Builder<NoFieldsSet> create()
7659	{
7660	return Builder<NoFieldsSet>(JSON::Object::create());
7661	}
7662
7663	void setSubtype(Subtype value)
7664	{
7665	JSON::ObjectBase::setString("subtype"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7666	}
7667
7668	void setDescription(const String& value)
7669	{
7670	JSON::ObjectBase::setString("description"_s, value);
7671	}
7672
7673	void setOverflow(bool value)
7674	{
7675	JSON::ObjectBase::setBoolean("overflow"_s, value);
7676	}
7677
7678	void setProperties(RefPtr<JSON::ArrayOf<Inspector::Protocol::Runtime::PropertyPreview>> value)
7679	{
7680	JSON::ObjectBase::setArray("properties"_s, WTFMove(value));
7681	}
7682
7683	void setEntries(RefPtr<JSON::ArrayOf<Inspector::Protocol::Runtime::EntryPreview>> value)
7684	{
7685	JSON::ObjectBase::setArray("entries"_s, WTFMove(value));
7686	}
7687
7688	void setSize(int value)
7689	{
7690	JSON::ObjectBase::setInteger("size"_s, value);
7691	}
7692	};
7693
7694	class PropertyPreview : public JSON::ObjectBase {
7695	public:
7696	// Named after property name 'type' while generating PropertyPreview.
7697	enum class Type {
7698	Object = `156`,
7699	Function = `157`,
7700	Undefined = `158`,
7701	String = `109`,
7702	Number = `108`,
7703	Boolean = `159`,
7704	Symbol = `160`,
7705	Accessor = `170`,
7706	}; // enum class Type
7707	// Named after property name 'subtype' while generating PropertyPreview.
7708	enum class Subtype {
7709	Array = `110`,
7710	Null = `111`,
7711	Node = `161`,
7712	Regexp = `162`,
7713	Date = `84`,
7714	Error = `54`,
7715	Map = `163`,
7716	Set = `164`,
7717	Weakmap = `165`,
7718	Weakset = `166`,
7719	Iterator = `167`,
7720	Class = `168`,
7721	Proxy = `169`,
7722	}; // enum class Subtype
7723	enum {
7724	NoFieldsSet = `0`,
7725	NameSet = `1` << `0`,
7726	TypeSet = `1` << `1`,
7727	AllFieldsSet = (NameSet \| TypeSet)
7728	};
7729
7730	template<int STATE>
7731	class Builder {
7732	private:
7733	RefPtr<JSON::Object> m_result;
7734
7735	template<int STEP> Builder<STATE \| STEP>& castState()
7736	{
7737	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7738	}
7739
7740	Builder(Ref</PropertyPreview/JSON::Object>&& object)
7741	: m_result (WTFMove(object))
7742	{
7743	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7744	}
7745	friend class PropertyPreview;
7746	public:
7747
7748	Builder<STATE \| NameSet>& setName(const String& value)
7749	{
7750	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
7751	m_result ->setString("name"_s, value);
7752	return castState<NameSet>();
7753	}
7754
7755	Builder<STATE \| TypeSet>& setType(Type value)
7756	{
7757	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7758	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7759	return castState<TypeSet>();
7760	}
7761
7762	Ref<PropertyPreview> release()
7763	{
7764	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7765	COMPILE_ASSERT(sizeof(PropertyPreview) == sizeof(JSON::Object), cannot_cast);
7766
7767	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7768	auto result = WTFMove(*reinterpret_cast<Ref<PropertyPreview>*>(&jsonResult));
7769	return result;
7770	}
7771	};
7772
7773	/*
7774	* Synthetic constructor:
7775	* Ref<PropertyPreview> result = PropertyPreview::create()
7776	* .setName(...)
7777	* .setType(...)
7778	* .release();
7779	*/
7780	static Builder<NoFieldsSet> create()
7781	{
7782	return Builder<NoFieldsSet>(JSON::Object::create());
7783	}
7784
7785	void setSubtype(Subtype value)
7786	{
7787	JSON::ObjectBase::setString("subtype"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7788	}
7789
7790	void setValue(const String& value)
7791	{
7792	JSON::ObjectBase::setString("value"_s, value);
7793	}
7794
7795	void setValuePreview(RefPtr<Inspector::Protocol::Runtime::ObjectPreview> value)
7796	{
7797	JSON::ObjectBase::setObject("valuePreview"_s, WTFMove(value));
7798	}
7799
7800	void setInternal(bool value)
7801	{
7802	JSON::ObjectBase::setBoolean("internal"_s, value);
7803	}
7804	};
7805
7806	class EntryPreview : public JSON::ObjectBase {
7807	public:
7808	enum {
7809	NoFieldsSet = `0`,
7810	ValueSet = `1` << `0`,
7811	AllFieldsSet = (ValueSet)
7812	};
7813
7814	template<int STATE>
7815	class Builder {
7816	private:
7817	RefPtr<JSON::Object> m_result;
7818
7819	template<int STEP> Builder<STATE \| STEP>& castState()
7820	{
7821	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7822	}
7823
7824	Builder(Ref</EntryPreview/JSON::Object>&& object)
7825	: m_result (WTFMove(object))
7826	{
7827	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7828	}
7829	friend class EntryPreview;
7830	public:
7831
7832	Builder<STATE \| ValueSet>& setValue(RefPtr<Inspector::Protocol::Runtime::ObjectPreview> value)
7833	{
7834	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
7835	m_result ->setObject("value"_s, value);
7836	return castState<ValueSet>();
7837	}
7838
7839	Ref<EntryPreview> release()
7840	{
7841	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7842	COMPILE_ASSERT(sizeof(EntryPreview) == sizeof(JSON::Object), cannot_cast);
7843
7844	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7845	auto result = WTFMove(*reinterpret_cast<Ref<EntryPreview>*>(&jsonResult));
7846	return result;
7847	}
7848	};
7849
7850	/*
7851	* Synthetic constructor:
7852	* Ref<EntryPreview> result = EntryPreview::create()
7853	* .setValue(...)
7854	* .release();
7855	*/
7856	static Builder<NoFieldsSet> create()
7857	{
7858	return Builder<NoFieldsSet>(JSON::Object::create());
7859	}
7860
7861	void setKey(RefPtr<Inspector::Protocol::Runtime::ObjectPreview> value)
7862	{
7863	JSON::ObjectBase::setObject("key"_s, WTFMove(value));
7864	}
7865	};
7866
7867	class CollectionEntry : public JSON::ObjectBase {
7868	public:
7869	enum {
7870	NoFieldsSet = `0`,
7871	ValueSet = `1` << `0`,
7872	AllFieldsSet = (ValueSet)
7873	};
7874
7875	template<int STATE>
7876	class Builder {
7877	private:
7878	RefPtr<JSON::Object> m_result;
7879
7880	template<int STEP> Builder<STATE \| STEP>& castState()
7881	{
7882	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7883	}
7884
7885	Builder(Ref</CollectionEntry/JSON::Object>&& object)
7886	: m_result (WTFMove(object))
7887	{
7888	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7889	}
7890	friend class CollectionEntry;
7891	public:
7892
7893	Builder<STATE \| ValueSet>& setValue(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7894	{
7895	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
7896	m_result ->setObject("value"_s, value);
7897	return castState<ValueSet>();
7898	}
7899
7900	Ref<CollectionEntry> release()
7901	{
7902	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7903	COMPILE_ASSERT(sizeof(CollectionEntry) == sizeof(JSON::Object), cannot_cast);
7904
7905	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7906	auto result = WTFMove(*reinterpret_cast<Ref<CollectionEntry>*>(&jsonResult));
7907	return result;
7908	}
7909	};
7910
7911	/*
7912	* Synthetic constructor:
7913	* Ref<CollectionEntry> result = CollectionEntry::create()
7914	* .setValue(...)
7915	* .release();
7916	*/
7917	static Builder<NoFieldsSet> create()
7918	{
7919	return Builder<NoFieldsSet>(JSON::Object::create());
7920	}
7921
7922	void setKey(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7923	{
7924	JSON::ObjectBase::setObject("key"_s, WTFMove(value));
7925	}
7926	};
7927
7928	/ Object property descriptor. /
7929	class PropertyDescriptor : public JSON::ObjectBase {
7930	public:
7931	enum {
7932	NoFieldsSet = `0`,
7933	NameSet = `1` << `0`,
7934	ConfigurableSet = `1` << `1`,
7935	EnumerableSet = `1` << `2`,
7936	AllFieldsSet = (NameSet \| ConfigurableSet \| EnumerableSet)
7937	};
7938
7939	template<int STATE>
7940	class Builder {
7941	private:
7942	RefPtr<JSON::Object> m_result;
7943
7944	template<int STEP> Builder<STATE \| STEP>& castState()
7945	{
7946	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7947	}
7948
7949	Builder(Ref</PropertyDescriptor/JSON::Object>&& object)
7950	: m_result (WTFMove(object))
7951	{
7952	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7953	}
7954	friend class PropertyDescriptor;
7955	public:
7956
7957	Builder<STATE \| NameSet>& setName(const String& value)
7958	{
7959	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
7960	m_result ->setString("name"_s, value);
7961	return castState<NameSet>();
7962	}
7963
7964	Builder<STATE \| ConfigurableSet>& setConfigurable(bool value)
7965	{
7966	COMPILE_ASSERT(!(STATE & ConfigurableSet), property_configurable_already_set);
7967	m_result ->setBoolean("configurable"_s, value);
7968	return castState<ConfigurableSet>();
7969	}
7970
7971	Builder<STATE \| EnumerableSet>& setEnumerable(bool value)
7972	{
7973	COMPILE_ASSERT(!(STATE & EnumerableSet), property_enumerable_already_set);
7974	m_result ->setBoolean("enumerable"_s, value);
7975	return castState<EnumerableSet>();
7976	}
7977
7978	Ref<PropertyDescriptor> release()
7979	{
7980	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7981	COMPILE_ASSERT(sizeof(PropertyDescriptor) == sizeof(JSON::Object), cannot_cast);
7982
7983	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7984	auto result = WTFMove(*reinterpret_cast<Ref<PropertyDescriptor>*>(&jsonResult));
7985	return result;
7986	}
7987	};
7988
7989	/*
7990	* Synthetic constructor:
7991	* Ref<PropertyDescriptor> result = PropertyDescriptor::create()
7992	* .setName(...)
7993	* .setConfigurable(...)
7994	* .setEnumerable(...)
7995	* .release();
7996	*/
7997	static Builder<NoFieldsSet> create()
7998	{
7999	return Builder<NoFieldsSet>(JSON::Object::create());
8000	}
8001
8002	void setValue(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
8003	{
8004	JSON::ObjectBase::setObject("value"_s, WTFMove(value));
8005	}
8006
8007	void setWritable(bool value)
8008	{
8009	JSON::ObjectBase::setBoolean("writable"_s, value);
8010	}
8011
8012	void setGet(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
8013	{
8014	JSON::ObjectBase::setObject("get"_s, WTFMove(value));
8015	}
8016
8017	void setSet(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
8018	{
8019	JSON::ObjectBase::setObject("set"_s, WTFMove(value));
8020	}
8021
8022	void setWasThrown(bool value)
8023	{
8024	JSON::ObjectBase::setBoolean("wasThrown"_s, value);
8025	}
8026
8027	void setIsOwn(bool value)
8028	{
8029	JSON::ObjectBase::setBoolean("isOwn"_s, value);
8030	}
8031
8032	void setSymbol(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
8033	{
8034	JSON::ObjectBase::setObject("symbol"_s, WTFMove(value));
8035	}
8036
8037	void setNativeGetter(bool value)
8038	{
8039	JSON::ObjectBase::setBoolean("nativeGetter"_s, value);
8040	}
8041	};
8042
8043	/ Object internal property descriptor. This property isn't normally visible in JavaScript code. /
8044	class InternalPropertyDescriptor : public JSON::ObjectBase {
8045	public:
8046	enum {
8047	NoFieldsSet = `0`,
8048	NameSet = `1` << `0`,
8049	AllFieldsSet = (NameSet)
8050	};
8051
8052	template<int STATE>
8053	class Builder {
8054	private:
8055	RefPtr<JSON::Object> m_result;
8056
8057	template<int STEP> Builder<STATE \| STEP>& castState()
8058	{
8059	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8060	}
8061
8062	Builder(Ref</InternalPropertyDescriptor/JSON::Object>&& object)
8063	: m_result (WTFMove(object))
8064	{
8065	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8066	}
8067	friend class InternalPropertyDescriptor;
8068	public:
8069
8070	Builder<STATE \| NameSet>& setName(const String& value)
8071	{
8072	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8073	m_result ->setString("name"_s, value);
8074	return castState<NameSet>();
8075	}
8076
8077	Ref<InternalPropertyDescriptor> release()
8078	{
8079	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8080	COMPILE_ASSERT(sizeof(InternalPropertyDescriptor) == sizeof(JSON::Object), cannot_cast);
8081
8082	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8083	auto result = WTFMove(*reinterpret_cast<Ref<InternalPropertyDescriptor>*>(&jsonResult));
8084	return result;
8085	}
8086	};
8087
8088	/*
8089	* Synthetic constructor:
8090	* Ref<InternalPropertyDescriptor> result = InternalPropertyDescriptor::create()
8091	* .setName(...)
8092	* .release();
8093	*/
8094	static Builder<NoFieldsSet> create()
8095	{
8096	return Builder<NoFieldsSet>(JSON::Object::create());
8097	}
8098
8099	void setValue(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
8100	{
8101	JSON::ObjectBase::setObject("value"_s, WTFMove(value));
8102	}
8103	};
8104
8105	/ Represents function call argument. Either remote object id <code>objectId</code> or primitive <code>value</code> or neither of (for undefined) them should be specified. /
8106	class CallArgument : public JSON::ObjectBase {
8107	public:
8108	enum {
8109	NoFieldsSet = `0`,
8110	AllFieldsSet = `0`
8111	};
8112
8113	template<int STATE>
8114	class Builder {
8115	private:
8116	RefPtr<JSON::Object> m_result;
8117
8118	template<int STEP> Builder<STATE \| STEP>& castState()
8119	{
8120	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8121	}
8122
8123	Builder(Ref</CallArgument/JSON::Object>&& object)
8124	: m_result (WTFMove(object))
8125	{
8126	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8127	}
8128	friend class CallArgument;
8129	public:
8130
8131	Ref<CallArgument> release()
8132	{
8133	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8134	COMPILE_ASSERT(sizeof(CallArgument) == sizeof(JSON::Object), cannot_cast);
8135
8136	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8137	auto result = WTFMove(*reinterpret_cast<Ref<CallArgument>*>(&jsonResult));
8138	return result;
8139	}
8140	};
8141
8142	/*
8143	* Synthetic constructor:
8144	* Ref<CallArgument> result = CallArgument::create()
8145	* .release();
8146	*/
8147	static Builder<NoFieldsSet> create()
8148	{
8149	return Builder<NoFieldsSet>(JSON::Object::create());
8150	}
8151
8152	void setValue(RefPtr<JSON::Value> value)
8153	{
8154	JSON::ObjectBase::setValue("value"_s, WTFMove(value));
8155	}
8156
8157	void setObjectId(const String& value)
8158	{
8159	JSON::ObjectBase::setString("objectId"_s, value);
8160	}
8161	};
8162
8163	/ Description of an isolated world. /
8164	class ExecutionContextDescription : public JSON::ObjectBase {
8165	public:
8166	enum {
8167	NoFieldsSet = `0`,
8168	IdSet = `1` << `0`,
8169	IsPageContextSet = `1` << `1`,
8170	NameSet = `1` << `2`,
8171	FrameIdSet = `1` << `3`,
8172	AllFieldsSet = (IdSet \| IsPageContextSet \| NameSet \| FrameIdSet)
8173	};
8174
8175	template<int STATE>
8176	class Builder {
8177	private:
8178	RefPtr<JSON::Object> m_result;
8179
8180	template<int STEP> Builder<STATE \| STEP>& castState()
8181	{
8182	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8183	}
8184
8185	Builder(Ref</ExecutionContextDescription/JSON::Object>&& object)
8186	: m_result (WTFMove(object))
8187	{
8188	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8189	}
8190	friend class ExecutionContextDescription;
8191	public:
8192
8193	Builder<STATE \| IdSet>& setId(int value)
8194	{
8195	COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
8196	m_result ->setInteger("id"_s, value);
8197	return castState<IdSet>();
8198	}
8199
8200	Builder<STATE \| IsPageContextSet>& setIsPageContext(bool value)
8201	{
8202	COMPILE_ASSERT(!(STATE & IsPageContextSet), property_isPageContext_already_set);
8203	m_result ->setBoolean("isPageContext"_s, value);
8204	return castState<IsPageContextSet>();
8205	}
8206
8207	Builder<STATE \| NameSet>& setName(const String& value)
8208	{
8209	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8210	m_result ->setString("name"_s, value);
8211	return castState<NameSet>();
8212	}
8213
8214	Builder<STATE \| FrameIdSet>& setFrameId(const String& value)
8215	{
8216	COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
8217	m_result ->setString("frameId"_s, value);
8218	return castState<FrameIdSet>();
8219	}
8220
8221	Ref<ExecutionContextDescription> release()
8222	{
8223	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8224	COMPILE_ASSERT(sizeof(ExecutionContextDescription) == sizeof(JSON::Object), cannot_cast);
8225
8226	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8227	auto result = WTFMove(*reinterpret_cast<Ref<ExecutionContextDescription>*>(&jsonResult));
8228	return result;
8229	}
8230	};
8231
8232	/*
8233	* Synthetic constructor:
8234	* Ref<ExecutionContextDescription> result = ExecutionContextDescription::create()
8235	* .setId(...)
8236	* .setIsPageContext(...)
8237	* .setName(...)
8238	* .setFrameId(...)
8239	* .release();
8240	*/
8241	static Builder<NoFieldsSet> create()
8242	{
8243	return Builder<NoFieldsSet>(JSON::Object::create());
8244	}
8245	};
8246
8247	/* Syntax error type: "none" for no error, "irrecoverable" for unrecoverable errors, "unterminated-literal" for when there is an unterminated literal, "recoverable" for when the expression is unfinished but valid so far. */
8248	enum class SyntaxErrorType {
8249	None = `171`,
8250	Irrecoverable = `172`,
8251	UnterminatedLiteral = `173`,
8252	Recoverable = `174`,
8253	}; // enum class SyntaxErrorType
8254	/ Range of an error in source code. /
8255	class ErrorRange : public JSON::ObjectBase {
8256	public:
8257	enum {
8258	NoFieldsSet = `0`,
8259	StartOffsetSet = `1` << `0`,
8260	EndOffsetSet = `1` << `1`,
8261	AllFieldsSet = (StartOffsetSet \| EndOffsetSet)
8262	};
8263
8264	template<int STATE>
8265	class Builder {
8266	private:
8267	RefPtr<JSON::Object> m_result;
8268
8269	template<int STEP> Builder<STATE \| STEP>& castState()
8270	{
8271	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8272	}
8273
8274	Builder(Ref</ErrorRange/JSON::Object>&& object)
8275	: m_result (WTFMove(object))
8276	{
8277	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8278	}
8279	friend class ErrorRange;
8280	public:
8281
8282	Builder<STATE \| StartOffsetSet>& setStartOffset(int value)
8283	{
8284	COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set);
8285	m_result ->setInteger("startOffset"_s, value);
8286	return castState<StartOffsetSet>();
8287	}
8288
8289	Builder<STATE \| EndOffsetSet>& setEndOffset(int value)
8290	{
8291	COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set);
8292	m_result ->setInteger("endOffset"_s, value);
8293	return castState<EndOffsetSet>();
8294	}
8295
8296	Ref<ErrorRange> release()
8297	{
8298	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8299	COMPILE_ASSERT(sizeof(ErrorRange) == sizeof(JSON::Object), cannot_cast);
8300
8301	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8302	auto result = WTFMove(*reinterpret_cast<Ref<ErrorRange>*>(&jsonResult));
8303	return result;
8304	}
8305	};
8306
8307	/*
8308	* Synthetic constructor:
8309	* Ref<ErrorRange> result = ErrorRange::create()
8310	* .setStartOffset(...)
8311	* .setEndOffset(...)
8312	* .release();
8313	*/
8314	static Builder<NoFieldsSet> create()
8315	{
8316	return Builder<NoFieldsSet>(JSON::Object::create());
8317	}
8318	};
8319
8320	class StructureDescription : public JSON::ObjectBase {
8321	public:
8322	enum {
8323	NoFieldsSet = `0`,
8324	AllFieldsSet = `0`
8325	};
8326
8327	template<int STATE>
8328	class Builder {
8329	private:
8330	RefPtr<JSON::Object> m_result;
8331
8332	template<int STEP> Builder<STATE \| STEP>& castState()
8333	{
8334	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8335	}
8336
8337	Builder(Ref</StructureDescription/JSON::Object>&& object)
8338	: m_result (WTFMove(object))
8339	{
8340	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8341	}
8342	friend class StructureDescription;
8343	public:
8344
8345	Ref<StructureDescription> release()
8346	{
8347	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8348	COMPILE_ASSERT(sizeof(StructureDescription) == sizeof(JSON::Object), cannot_cast);
8349
8350	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8351	auto result = WTFMove(*reinterpret_cast<Ref<StructureDescription>*>(&jsonResult));
8352	return result;
8353	}
8354	};
8355
8356	/*
8357	* Synthetic constructor:
8358	* Ref<StructureDescription> result = StructureDescription::create()
8359	* .release();
8360	*/
8361	static Builder<NoFieldsSet> create()
8362	{
8363	return Builder<NoFieldsSet>(JSON::Object::create());
8364	}
8365
8366	void setFields(RefPtr<JSON::ArrayOf<String>> value)
8367	{
8368	JSON::ObjectBase::setArray("fields"_s, WTFMove(value));
8369	}
8370
8371	void setOptionalFields(RefPtr<JSON::ArrayOf<String>> value)
8372	{
8373	JSON::ObjectBase::setArray("optionalFields"_s, WTFMove(value));
8374	}
8375
8376	void setConstructorName(const String& value)
8377	{
8378	JSON::ObjectBase::setString("constructorName"_s, value);
8379	}
8380
8381	void setPrototypeStructure(RefPtr<Inspector::Protocol::Runtime::StructureDescription> value)
8382	{
8383	JSON::ObjectBase::setObject("prototypeStructure"_s, WTFMove(value));
8384	}
8385
8386	void setIsImprecise(bool value)
8387	{
8388	JSON::ObjectBase::setBoolean("isImprecise"_s, value);
8389	}
8390	};
8391
8392	class TypeSet : public JSON::ObjectBase {
8393	public:
8394	enum {
8395	NoFieldsSet = `0`,
8396	IsFunctionSet = `1` << `0`,
8397	IsUndefinedSet = `1` << `1`,
8398	IsNullSet = `1` << `2`,
8399	IsBooleanSet = `1` << `3`,
8400	IsIntegerSet = `1` << `4`,
8401	IsNumberSet = `1` << `5`,
8402	IsStringSet = `1` << `6`,
8403	IsObjectSet = `1` << `7`,
8404	IsSymbolSet = `1` << `8`,
8405	AllFieldsSet = (IsFunctionSet \| IsUndefinedSet \| IsNullSet \| IsBooleanSet \| IsIntegerSet \| IsNumberSet \| IsStringSet \| IsObjectSet \| IsSymbolSet)
8406	};
8407
8408	template<int STATE>
8409	class Builder {
8410	private:
8411	RefPtr<JSON::Object> m_result;
8412
8413	template<int STEP> Builder<STATE \| STEP>& castState()
8414	{
8415	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8416	}
8417
8418	Builder(Ref</TypeSet/JSON::Object>&& object)
8419	: m_result (WTFMove(object))
8420	{
8421	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8422	}
8423	friend class TypeSet;
8424	public:
8425
8426	Builder<STATE \| IsFunctionSet>& setIsFunction(bool value)
8427	{
8428	COMPILE_ASSERT(!(STATE & IsFunctionSet), property_isFunction_already_set);
8429	m_result ->setBoolean("isFunction"_s, value);
8430	return castState<IsFunctionSet>();
8431	}
8432
8433	Builder<STATE \| IsUndefinedSet>& setIsUndefined(bool value)
8434	{
8435	COMPILE_ASSERT(!(STATE & IsUndefinedSet), property_isUndefined_already_set);
8436	m_result ->setBoolean("isUndefined"_s, value);
8437	return castState<IsUndefinedSet>();
8438	}
8439
8440	Builder<STATE \| IsNullSet>& setIsNull(bool value)
8441	{
8442	COMPILE_ASSERT(!(STATE & IsNullSet), property_isNull_already_set);
8443	m_result ->setBoolean("isNull"_s, value);
8444	return castState<IsNullSet>();
8445	}
8446
8447	Builder<STATE \| IsBooleanSet>& setIsBoolean(bool value)
8448	{
8449	COMPILE_ASSERT(!(STATE & IsBooleanSet), property_isBoolean_already_set);
8450	m_result ->setBoolean("isBoolean"_s, value);
8451	return castState<IsBooleanSet>();
8452	}
8453
8454	Builder<STATE \| IsIntegerSet>& setIsInteger(bool value)
8455	{
8456	COMPILE_ASSERT(!(STATE & IsIntegerSet), property_isInteger_already_set);
8457	m_result ->setBoolean("isInteger"_s, value);
8458	return castState<IsIntegerSet>();
8459	}
8460
8461	Builder<STATE \| IsNumberSet>& setIsNumber(bool value)
8462	{
8463	COMPILE_ASSERT(!(STATE & IsNumberSet), property_isNumber_already_set);
8464	m_result ->setBoolean("isNumber"_s, value);
8465	return castState<IsNumberSet>();
8466	}
8467
8468	Builder<STATE \| IsStringSet>& setIsString(bool value)
8469	{
8470	COMPILE_ASSERT(!(STATE & IsStringSet), property_isString_already_set);
8471	m_result ->setBoolean("isString"_s, value);
8472	return castState<IsStringSet>();
8473	}
8474
8475	Builder<STATE \| IsObjectSet>& setIsObject(bool value)
8476	{
8477	COMPILE_ASSERT(!(STATE & IsObjectSet), property_isObject_already_set);
8478	m_result ->setBoolean("isObject"_s, value);
8479	return castState<IsObjectSet>();
8480	}
8481
8482	Builder<STATE \| IsSymbolSet>& setIsSymbol(bool value)
8483	{
8484	COMPILE_ASSERT(!(STATE & IsSymbolSet), property_isSymbol_already_set);
8485	m_result ->setBoolean("isSymbol"_s, value);
8486	return castState<IsSymbolSet>();
8487	}
8488
8489	Ref<TypeSet> release()
8490	{
8491	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8492	COMPILE_ASSERT(sizeof(TypeSet) == sizeof(JSON::Object), cannot_cast);
8493
8494	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8495	auto result = WTFMove(*reinterpret_cast<Ref<TypeSet>*>(&jsonResult));
8496	return result;
8497	}
8498	};
8499
8500	/*
8501	* Synthetic constructor:
8502	* Ref<TypeSet> result = TypeSet::create()
8503	* .setIsFunction(...)
8504	* .setIsUndefined(...)
8505	* .setIsNull(...)
8506	* .setIsBoolean(...)
8507	* .setIsInteger(...)
8508	* .setIsNumber(...)
8509	* .setIsString(...)
8510	* .setIsObject(...)
8511	* .setIsSymbol(...)
8512	* .release();
8513	*/
8514	static Builder<NoFieldsSet> create()
8515	{
8516	return Builder<NoFieldsSet>(JSON::Object::create());
8517	}
8518	};
8519
8520	/ Container for type information that has been gathered. /
8521	class TypeDescription : public JSON::ObjectBase {
8522	public:
8523	enum {
8524	NoFieldsSet = `0`,
8525	IsValidSet = `1` << `0`,
8526	AllFieldsSet = (IsValidSet)
8527	};
8528
8529	template<int STATE>
8530	class Builder {
8531	private:
8532	RefPtr<JSON::Object> m_result;
8533
8534	template<int STEP> Builder<STATE \| STEP>& castState()
8535	{
8536	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8537	}
8538
8539	Builder(Ref</TypeDescription/JSON::Object>&& object)
8540	: m_result (WTFMove(object))
8541	{
8542	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8543	}
8544	friend class TypeDescription;
8545	public:
8546
8547	Builder<STATE \| IsValidSet>& setIsValid(bool value)
8548	{
8549	COMPILE_ASSERT(!(STATE & IsValidSet), property_isValid_already_set);
8550	m_result ->setBoolean("isValid"_s, value);
8551	return castState<IsValidSet>();
8552	}
8553
8554	Ref<TypeDescription> release()
8555	{
8556	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8557	COMPILE_ASSERT(sizeof(TypeDescription) == sizeof(JSON::Object), cannot_cast);
8558
8559	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8560	auto result = WTFMove(*reinterpret_cast<Ref<TypeDescription>*>(&jsonResult));
8561	return result;
8562	}
8563	};
8564
8565	/*
8566	* Synthetic constructor:
8567	* Ref<TypeDescription> result = TypeDescription::create()
8568	* .setIsValid(...)
8569	* .release();
8570	*/
8571	static Builder<NoFieldsSet> create()
8572	{
8573	return Builder<NoFieldsSet>(JSON::Object::create());
8574	}
8575
8576	void setLeastCommonAncestor(const String& value)
8577	{
8578	JSON::ObjectBase::setString("leastCommonAncestor"_s, value);
8579	}
8580
8581	void setTypeSet(RefPtr<Inspector::Protocol::Runtime::TypeSet> value)
8582	{
8583	JSON::ObjectBase::setObject("typeSet"_s, WTFMove(value));
8584	}
8585
8586	void setStructures(RefPtr<JSON::ArrayOf<Inspector::Protocol::Runtime::StructureDescription>> value)
8587	{
8588	JSON::ObjectBase::setArray("structures"_s, WTFMove(value));
8589	}
8590
8591	void setIsTruncated(bool value)
8592	{
8593	JSON::ObjectBase::setBoolean("isTruncated"_s, value);
8594	}
8595	};
8596
8597	/ Describes the location of an expression we want type information for. /
8598	class TypeLocation : public JSON::ObjectBase {
8599	public:
8600	enum {
8601	NoFieldsSet = `0`,
8602	TypeInformationDescriptorSet = `1` << `0`,
8603	SourceIDSet = `1` << `1`,
8604	DivotSet = `1` << `2`,
8605	AllFieldsSet = (TypeInformationDescriptorSet \| SourceIDSet \| DivotSet)
8606	};
8607
8608	template<int STATE>
8609	class Builder {
8610	private:
8611	RefPtr<JSON::Object> m_result;
8612
8613	template<int STEP> Builder<STATE \| STEP>& castState()
8614	{
8615	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8616	}
8617
8618	Builder(Ref</TypeLocation/JSON::Object>&& object)
8619	: m_result (WTFMove(object))
8620	{
8621	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8622	}
8623	friend class TypeLocation;
8624	public:
8625
8626	Builder<STATE \| TypeInformationDescriptorSet>& setTypeInformationDescriptor(int value)
8627	{
8628	COMPILE_ASSERT(!(STATE & TypeInformationDescriptorSet), property_typeInformationDescriptor_already_set);
8629	m_result ->setInteger("typeInformationDescriptor"_s, value);
8630	return castState<TypeInformationDescriptorSet>();
8631	}
8632
8633	Builder<STATE \| SourceIDSet>& setSourceID(const String& value)
8634	{
8635	COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set);
8636	m_result ->setString("sourceID"_s, value);
8637	return castState<SourceIDSet>();
8638	}
8639
8640	Builder<STATE \| DivotSet>& setDivot(int value)
8641	{
8642	COMPILE_ASSERT(!(STATE & DivotSet), property_divot_already_set);
8643	m_result ->setInteger("divot"_s, value);
8644	return castState<DivotSet>();
8645	}
8646
8647	Ref<TypeLocation> release()
8648	{
8649	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8650	COMPILE_ASSERT(sizeof(TypeLocation) == sizeof(JSON::Object), cannot_cast);
8651
8652	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8653	auto result = WTFMove(*reinterpret_cast<Ref<TypeLocation>*>(&jsonResult));
8654	return result;
8655	}
8656	};
8657
8658	/*
8659	* Synthetic constructor:
8660	* Ref<TypeLocation> result = TypeLocation::create()
8661	* .setTypeInformationDescriptor(...)
8662	* .setSourceID(...)
8663	* .setDivot(...)
8664	* .release();
8665	*/
8666	static Builder<NoFieldsSet> create()
8667	{
8668	return Builder<NoFieldsSet>(JSON::Object::create());
8669	}
8670	};
8671
8672	/* From Wikipedia: a basic block is a portion of the code within a program with only one entry point and only one exit point. This type gives the location of a basic block and if that basic block has executed. */
8673	class BasicBlock : public JSON::ObjectBase {
8674	public:
8675	enum {
8676	NoFieldsSet = `0`,
8677	StartOffsetSet = `1` << `0`,
8678	EndOffsetSet = `1` << `1`,
8679	HasExecutedSet = `1` << `2`,
8680	ExecutionCountSet = `1` << `3`,
8681	AllFieldsSet = (StartOffsetSet \| EndOffsetSet \| HasExecutedSet \| ExecutionCountSet)
8682	};
8683
8684	template<int STATE>
8685	class Builder {
8686	private:
8687	RefPtr<JSON::Object> m_result;
8688
8689	template<int STEP> Builder<STATE \| STEP>& castState()
8690	{
8691	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8692	}
8693
8694	Builder(Ref</BasicBlock/JSON::Object>&& object)
8695	: m_result (WTFMove(object))
8696	{
8697	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8698	}
8699	friend class BasicBlock;
8700	public:
8701
8702	Builder<STATE \| StartOffsetSet>& setStartOffset(int value)
8703	{
8704	COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set);
8705	m_result ->setInteger("startOffset"_s, value);
8706	return castState<StartOffsetSet>();
8707	}
8708
8709	Builder<STATE \| EndOffsetSet>& setEndOffset(int value)
8710	{
8711	COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set);
8712	m_result ->setInteger("endOffset"_s, value);
8713	return castState<EndOffsetSet>();
8714	}
8715
8716	Builder<STATE \| HasExecutedSet>& setHasExecuted(bool value)
8717	{
8718	COMPILE_ASSERT(!(STATE & HasExecutedSet), property_hasExecuted_already_set);
8719	m_result ->setBoolean("hasExecuted"_s, value);
8720	return castState<HasExecutedSet>();
8721	}
8722
8723	Builder<STATE \| ExecutionCountSet>& setExecutionCount(int value)
8724	{
8725	COMPILE_ASSERT(!(STATE & ExecutionCountSet), property_executionCount_already_set);
8726	m_result ->setInteger("executionCount"_s, value);
8727	return castState<ExecutionCountSet>();
8728	}
8729
8730	Ref<BasicBlock> release()
8731	{
8732	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8733	COMPILE_ASSERT(sizeof(BasicBlock) == sizeof(JSON::Object), cannot_cast);
8734
8735	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8736	auto result = WTFMove(*reinterpret_cast<Ref<BasicBlock>*>(&jsonResult));
8737	return result;
8738	}
8739	};
8740
8741	/*
8742	* Synthetic constructor:
8743	* Ref<BasicBlock> result = BasicBlock::create()
8744	* .setStartOffset(...)
8745	* .setEndOffset(...)
8746	* .setHasExecuted(...)
8747	* .setExecutionCount(...)
8748	* .release();
8749	*/
8750	static Builder<NoFieldsSet> create()
8751	{
8752	return Builder<NoFieldsSet>(JSON::Object::create());
8753	}
8754	};
8755
8756	} // Runtime
8757
8758	namespace ScriptProfiler {
8759	/ /
8760	enum class EventType {
8761	API = `175`,
8762	Microtask = `176`,
8763	Other = `132`,
8764	}; // enum class EventType
8765	class Event : public JSON::ObjectBase {
8766	public:
8767	enum {
8768	NoFieldsSet = `0`,
8769	StartTimeSet = `1` << `0`,
8770	EndTimeSet = `1` << `1`,
8771	TypeSet = `1` << `2`,
8772	AllFieldsSet = (StartTimeSet \| EndTimeSet \| TypeSet)
8773	};
8774
8775	template<int STATE>
8776	class Builder {
8777	private:
8778	RefPtr<JSON::Object> m_result;
8779
8780	template<int STEP> Builder<STATE \| STEP>& castState()
8781	{
8782	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8783	}
8784
8785	Builder(Ref</Event/JSON::Object>&& object)
8786	: m_result (WTFMove(object))
8787	{
8788	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8789	}
8790	friend class Event;
8791	public:
8792
8793	Builder<STATE \| StartTimeSet>& setStartTime(double value)
8794	{
8795	COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
8796	m_result ->setDouble("startTime"_s, value);
8797	return castState<StartTimeSet>();
8798	}
8799
8800	Builder<STATE \| EndTimeSet>& setEndTime(double value)
8801	{
8802	COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set);
8803	m_result ->setDouble("endTime"_s, value);
8804	return castState<EndTimeSet>();
8805	}
8806
8807	Builder<STATE \| TypeSet>& setType(Inspector::Protocol::ScriptProfiler::EventType value)
8808	{
8809	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8810	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
8811	return castState<TypeSet>();
8812	}
8813
8814	Ref<Event> release()
8815	{
8816	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8817	COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
8818
8819	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8820	auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
8821	return result;
8822	}
8823	};
8824
8825	/*
8826	* Synthetic constructor:
8827	* Ref<Event> result = Event::create()
8828	* .setStartTime(...)
8829	* .setEndTime(...)
8830	* .setType(...)
8831	* .release();
8832	*/
8833	static Builder<NoFieldsSet> create()
8834	{
8835	return Builder<NoFieldsSet>(JSON::Object::create());
8836	}
8837	};
8838
8839	class ExpressionLocation : public JSON::ObjectBase {
8840	public:
8841	enum {
8842	NoFieldsSet = `0`,
8843	LineSet = `1` << `0`,
8844	ColumnSet = `1` << `1`,
8845	AllFieldsSet = (LineSet \| ColumnSet)
8846	};
8847
8848	template<int STATE>
8849	class Builder {
8850	private:
8851	RefPtr<JSON::Object> m_result;
8852
8853	template<int STEP> Builder<STATE \| STEP>& castState()
8854	{
8855	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8856	}
8857
8858	Builder(Ref</ExpressionLocation/JSON::Object>&& object)
8859	: m_result (WTFMove(object))
8860	{
8861	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8862	}
8863	friend class ExpressionLocation;
8864	public:
8865
8866	Builder<STATE \| LineSet>& setLine(int value)
8867	{
8868	COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set);
8869	m_result ->setInteger("line"_s, value);
8870	return castState<LineSet>();
8871	}
8872
8873	Builder<STATE \| ColumnSet>& setColumn(int value)
8874	{
8875	COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set);
8876	m_result ->setInteger("column"_s, value);
8877	return castState<ColumnSet>();
8878	}
8879
8880	Ref<ExpressionLocation> release()
8881	{
8882	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8883	COMPILE_ASSERT(sizeof(ExpressionLocation) == sizeof(JSON::Object), cannot_cast);
8884
8885	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8886	auto result = WTFMove(*reinterpret_cast<Ref<ExpressionLocation>*>(&jsonResult));
8887	return result;
8888	}
8889	};
8890
8891	/*
8892	* Synthetic constructor:
8893	* Ref<ExpressionLocation> result = ExpressionLocation::create()
8894	* .setLine(...)
8895	* .setColumn(...)
8896	* .release();
8897	*/
8898	static Builder<NoFieldsSet> create()
8899	{
8900	return Builder<NoFieldsSet>(JSON::Object::create());
8901	}
8902	};
8903
8904	class StackFrame : public JSON::ObjectBase {
8905	public:
8906	enum {
8907	NoFieldsSet = `0`,
8908	SourceIDSet = `1` << `0`,
8909	NameSet = `1` << `1`,
8910	LineSet = `1` << `2`,
8911	ColumnSet = `1` << `3`,
8912	UrlSet = `1` << `4`,
8913	AllFieldsSet = (SourceIDSet \| NameSet \| LineSet \| ColumnSet \| UrlSet)
8914	};
8915
8916	template<int STATE>
8917	class Builder {
8918	private:
8919	RefPtr<JSON::Object> m_result;
8920
8921	template<int STEP> Builder<STATE \| STEP>& castState()
8922	{
8923	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8924	}
8925
8926	Builder(Ref</StackFrame/JSON::Object>&& object)
8927	: m_result (WTFMove(object))
8928	{
8929	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8930	}
8931	friend class StackFrame;
8932	public:
8933
8934	Builder<STATE \| SourceIDSet>& setSourceID(const String& value)
8935	{
8936	COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set);
8937	m_result ->setString("sourceID"_s, value);
8938	return castState<SourceIDSet>();
8939	}
8940
8941	Builder<STATE \| NameSet>& setName(const String& value)
8942	{
8943	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8944	m_result ->setString("name"_s, value);
8945	return castState<NameSet>();
8946	}
8947
8948	Builder<STATE \| LineSet>& setLine(int value)
8949	{
8950	COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set);
8951	m_result ->setInteger("line"_s, value);
8952	return castState<LineSet>();
8953	}
8954
8955	Builder<STATE \| ColumnSet>& setColumn(int value)
8956	{
8957	COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set);
8958	m_result ->setInteger("column"_s, value);
8959	return castState<ColumnSet>();
8960	}
8961
8962	Builder<STATE \| UrlSet>& setUrl(const String& value)
8963	{
8964	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
8965	m_result ->setString("url"_s, value);
8966	return castState<UrlSet>();
8967	}
8968
8969	Ref<StackFrame> release()
8970	{
8971	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8972	COMPILE_ASSERT(sizeof(StackFrame) == sizeof(JSON::Object), cannot_cast);
8973
8974	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8975	auto result = WTFMove(*reinterpret_cast<Ref<StackFrame>*>(&jsonResult));
8976	return result;
8977	}
8978	};
8979
8980	/*
8981	* Synthetic constructor:
8982	* Ref<StackFrame> result = StackFrame::create()
8983	* .setSourceID(...)
8984	* .setName(...)
8985	* .setLine(...)
8986	* .setColumn(...)
8987	* .setUrl(...)
8988	* .release();
8989	*/
8990	static Builder<NoFieldsSet> create()
8991	{
8992	return Builder<NoFieldsSet>(JSON::Object::create());
8993	}
8994
8995	void setExpressionLocation(RefPtr<Inspector::Protocol::ScriptProfiler::ExpressionLocation> value)
8996	{
8997	JSON::ObjectBase::setObject("expressionLocation"_s, WTFMove(value));
8998	}
8999	};
9000
9001	class StackTrace : public JSON::ObjectBase {
9002	public:
9003	enum {
9004	NoFieldsSet = `0`,
9005	TimestampSet = `1` << `0`,
9006	StackFramesSet = `1` << `1`,
9007	AllFieldsSet = (TimestampSet \| StackFramesSet)
9008	};
9009
9010	template<int STATE>
9011	class Builder {
9012	private:
9013	RefPtr<JSON::Object> m_result;
9014
9015	template<int STEP> Builder<STATE \| STEP>& castState()
9016	{
9017	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9018	}
9019
9020	Builder(Ref</StackTrace/JSON::Object>&& object)
9021	: m_result (WTFMove(object))
9022	{
9023	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9024	}
9025	friend class StackTrace;
9026	public:
9027
9028	Builder<STATE \| TimestampSet>& setTimestamp(double value)
9029	{
9030	COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
9031	m_result ->setDouble("timestamp"_s, value);
9032	return castState<TimestampSet>();
9033	}
9034
9035	Builder<STATE \| StackFramesSet>& setStackFrames(RefPtr<JSON::ArrayOf<Inspector::Protocol::ScriptProfiler::StackFrame>> value)
9036	{
9037	COMPILE_ASSERT(!(STATE & StackFramesSet), property_stackFrames_already_set);
9038	m_result ->setArray("stackFrames"_s, value);
9039	return castState<StackFramesSet>();
9040	}
9041
9042	Ref<StackTrace> release()
9043	{
9044	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9045	COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast);
9046
9047	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9048	auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult));
9049	return result;
9050	}
9051	};
9052
9053	/*
9054	* Synthetic constructor:
9055	* Ref<StackTrace> result = StackTrace::create()
9056	* .setTimestamp(...)
9057	* .setStackFrames(...)
9058	* .release();
9059	*/
9060	static Builder<NoFieldsSet> create()
9061	{
9062	return Builder<NoFieldsSet>(JSON::Object::create());
9063	}
9064	};
9065
9066	class Samples : public JSON::ObjectBase {
9067	public:
9068	enum {
9069	NoFieldsSet = `0`,
9070	StackTracesSet = `1` << `0`,
9071	AllFieldsSet = (StackTracesSet)
9072	};
9073
9074	template<int STATE>
9075	class Builder {
9076	private:
9077	RefPtr<JSON::Object> m_result;
9078
9079	template<int STEP> Builder<STATE \| STEP>& castState()
9080	{
9081	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9082	}
9083
9084	Builder(Ref</Samples/JSON::Object>&& object)
9085	: m_result (WTFMove(object))
9086	{
9087	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9088	}
9089	friend class Samples;
9090	public:
9091
9092	Builder<STATE \| StackTracesSet>& setStackTraces(RefPtr<JSON::ArrayOf<Inspector::Protocol::ScriptProfiler::StackTrace>> value)
9093	{
9094	COMPILE_ASSERT(!(STATE & StackTracesSet), property_stackTraces_already_set);
9095	m_result ->setArray("stackTraces"_s, value);
9096	return castState<StackTracesSet>();
9097	}
9098
9099	Ref<Samples> release()
9100	{
9101	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9102	COMPILE_ASSERT(sizeof(Samples) == sizeof(JSON::Object), cannot_cast);
9103
9104	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9105	auto result = WTFMove(*reinterpret_cast<Ref<Samples>*>(&jsonResult));
9106	return result;
9107	}
9108	};
9109
9110	/*
9111	* Synthetic constructor:
9112	* Ref<Samples> result = Samples::create()
9113	* .setStackTraces(...)
9114	* .release();
9115	*/
9116	static Builder<NoFieldsSet> create()
9117	{
9118	return Builder<NoFieldsSet>(JSON::Object::create());
9119	}
9120	};
9121
9122	} // ScriptProfiler
9123
9124	namespace Security {
9125	/ Information about a SSL connection to display in the frontend. /
9126	class Connection : public JSON::ObjectBase {
9127	public:
9128	enum {
9129	NoFieldsSet = `0`,
9130	AllFieldsSet = `0`
9131	};
9132
9133	template<int STATE>
9134	class Builder {
9135	private:
9136	RefPtr<JSON::Object> m_result;
9137
9138	template<int STEP> Builder<STATE \| STEP>& castState()
9139	{
9140	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9141	}
9142
9143	Builder(Ref</Connection/JSON::Object>&& object)
9144	: m_result (WTFMove(object))
9145	{
9146	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9147	}
9148	friend class Connection;
9149	public:
9150
9151	Ref<Connection> release()
9152	{
9153	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9154	COMPILE_ASSERT(sizeof(Connection) == sizeof(JSON::Object), cannot_cast);
9155
9156	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9157	auto result = WTFMove(*reinterpret_cast<Ref<Connection>*>(&jsonResult));
9158	return result;
9159	}
9160	};
9161
9162	/*
9163	* Synthetic constructor:
9164	* Ref<Connection> result = Connection::create()
9165	* .release();
9166	*/
9167	static Builder<NoFieldsSet> create()
9168	{
9169	return Builder<NoFieldsSet>(JSON::Object::create());
9170	}
9171
9172	void setProtocol(const String& value)
9173	{
9174	JSON::ObjectBase::setString("protocol"_s, value);
9175	}
9176
9177	void setCipher(const String& value)
9178	{
9179	JSON::ObjectBase::setString("cipher"_s, value);
9180	}
9181	};
9182
9183	/ Information about a SSL certificate to display in the frontend. /
9184	class Certificate : public JSON::ObjectBase {
9185	public:
9186	enum {
9187	NoFieldsSet = `0`,
9188	AllFieldsSet = `0`
9189	};
9190
9191	template<int STATE>
9192	class Builder {
9193	private:
9194	RefPtr<JSON::Object> m_result;
9195
9196	template<int STEP> Builder<STATE \| STEP>& castState()
9197	{
9198	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9199	}
9200
9201	Builder(Ref</Certificate/JSON::Object>&& object)
9202	: m_result (WTFMove(object))
9203	{
9204	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9205	}
9206	friend class Certificate;
9207	public:
9208
9209	Ref<Certificate> release()
9210	{
9211	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9212	COMPILE_ASSERT(sizeof(Certificate) == sizeof(JSON::Object), cannot_cast);
9213
9214	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9215	auto result = WTFMove(*reinterpret_cast<Ref<Certificate>*>(&jsonResult));
9216	return result;
9217	}
9218	};
9219
9220	/*
9221	* Synthetic constructor:
9222	* Ref<Certificate> result = Certificate::create()
9223	* .release();
9224	*/
9225	static Builder<NoFieldsSet> create()
9226	{
9227	return Builder<NoFieldsSet>(JSON::Object::create());
9228	}
9229
9230	void setSubject(const String& value)
9231	{
9232	JSON::ObjectBase::setString("subject"_s, value);
9233	}
9234
9235	void setValidFrom(double value)
9236	{
9237	JSON::ObjectBase::setDouble("validFrom"_s, value);
9238	}
9239
9240	void setValidUntil(double value)
9241	{
9242	JSON::ObjectBase::setDouble("validUntil"_s, value);
9243	}
9244
9245	void setDnsNames(RefPtr<JSON::ArrayOf<String>> value)
9246	{
9247	JSON::ObjectBase::setArray("dnsNames"_s, WTFMove(value));
9248	}
9249
9250	void setIpAddresses(RefPtr<JSON::ArrayOf<String>> value)
9251	{
9252	JSON::ObjectBase::setArray("ipAddresses"_s, WTFMove(value));
9253	}
9254	};
9255
9256	/ Security information for a given Network.Response. /
9257	class Security : public JSON::ObjectBase {
9258	public:
9259	enum {
9260	NoFieldsSet = `0`,
9261	AllFieldsSet = `0`
9262	};
9263
9264	template<int STATE>
9265	class Builder {
9266	private:
9267	RefPtr<JSON::Object> m_result;
9268
9269	template<int STEP> Builder<STATE \| STEP>& castState()
9270	{
9271	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9272	}
9273
9274	Builder(Ref</Security/JSON::Object>&& object)
9275	: m_result (WTFMove(object))
9276	{
9277	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9278	}
9279	friend class Security;
9280	public:
9281
9282	Ref<Security> release()
9283	{
9284	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9285	COMPILE_ASSERT(sizeof(Security) == sizeof(JSON::Object), cannot_cast);
9286
9287	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9288	auto result = WTFMove(*reinterpret_cast<Ref<Security>*>(&jsonResult));
9289	return result;
9290	}
9291	};
9292
9293	/*
9294	* Synthetic constructor:
9295	* Ref<Security> result = Security::create()
9296	* .release();
9297	*/
9298	static Builder<NoFieldsSet> create()
9299	{
9300	return Builder<NoFieldsSet>(JSON::Object::create());
9301	}
9302
9303	void setConnection(RefPtr<Inspector::Protocol::Security::Connection> value)
9304	{
9305	JSON::ObjectBase::setObject("connection"_s, WTFMove(value));
9306	}
9307
9308	void setCertificate(RefPtr<Inspector::Protocol::Security::Certificate> value)
9309	{
9310	JSON::ObjectBase::setObject("certificate"_s, WTFMove(value));
9311	}
9312	};
9313
9314	} // Security
9315
9316	namespace ServiceWorker {
9317	/ ServiceWorker metadata and initial state. /
9318	class Configuration : public JSON::ObjectBase {
9319	public:
9320	enum {
9321	NoFieldsSet = `0`,
9322	TargetIdSet = `1` << `0`,
9323	SecurityOriginSet = `1` << `1`,
9324	UrlSet = `1` << `2`,
9325	ContentSet = `1` << `3`,
9326	AllFieldsSet = (TargetIdSet \| SecurityOriginSet \| UrlSet \| ContentSet)
9327	};
9328
9329	template<int STATE>
9330	class Builder {
9331	private:
9332	RefPtr<JSON::Object> m_result;
9333
9334	template<int STEP> Builder<STATE \| STEP>& castState()
9335	{
9336	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9337	}
9338
9339	Builder(Ref</Configuration/JSON::Object>&& object)
9340	: m_result (WTFMove(object))
9341	{
9342	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9343	}
9344	friend class Configuration;
9345	public:
9346
9347	Builder<STATE \| TargetIdSet>& setTargetId(const String& value)
9348	{
9349	COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set);
9350	m_result ->setString("targetId"_s, value);
9351	return castState<TargetIdSet>();
9352	}
9353
9354	Builder<STATE \| SecurityOriginSet>& setSecurityOrigin(const String& value)
9355	{
9356	COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
9357	m_result ->setString("securityOrigin"_s, value);
9358	return castState<SecurityOriginSet>();
9359	}
9360
9361	Builder<STATE \| UrlSet>& setUrl(const String& value)
9362	{
9363	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
9364	m_result ->setString("url"_s, value);
9365	return castState<UrlSet>();
9366	}
9367
9368	Builder<STATE \| ContentSet>& setContent(const String& value)
9369	{
9370	COMPILE_ASSERT(!(STATE & ContentSet), property_content_already_set);
9371	m_result ->setString("content"_s, value);
9372	return castState<ContentSet>();
9373	}
9374
9375	Ref<Configuration> release()
9376	{
9377	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9378	COMPILE_ASSERT(sizeof(Configuration) == sizeof(JSON::Object), cannot_cast);
9379
9380	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9381	auto result = WTFMove(*reinterpret_cast<Ref<Configuration>*>(&jsonResult));
9382	return result;
9383	}
9384	};
9385
9386	/*
9387	* Synthetic constructor:
9388	* Ref<Configuration> result = Configuration::create()
9389	* .setTargetId(...)
9390	* .setSecurityOrigin(...)
9391	* .setUrl(...)
9392	* .setContent(...)
9393	* .release();
9394	*/
9395	static Builder<NoFieldsSet> create()
9396	{
9397	return Builder<NoFieldsSet>(JSON::Object::create());
9398	}
9399	};
9400
9401	} // ServiceWorker
9402
9403	namespace Target {
9404	/ Description of a target. /
9405	class TargetInfo : public JSON::ObjectBase {
9406	public:
9407	// Named after property name 'type' while generating TargetInfo.
9408	enum class Type {
9409	JavaScript = `35`,
9410	Page = `81`,
9411	Worker = `177`,
9412	ServiceWorker = `178`,
9413	}; // enum class Type
9414	enum {
9415	NoFieldsSet = `0`,
9416	TargetIdSet = `1` << `0`,
9417	TypeSet = `1` << `1`,
9418	AllFieldsSet = (TargetIdSet \| TypeSet)
9419	};
9420
9421	template<int STATE>
9422	class Builder {
9423	private:
9424	RefPtr<JSON::Object> m_result;
9425
9426	template<int STEP> Builder<STATE \| STEP>& castState()
9427	{
9428	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9429	}
9430
9431	Builder(Ref</TargetInfo/JSON::Object>&& object)
9432	: m_result (WTFMove(object))
9433	{
9434	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9435	}
9436	friend class TargetInfo;
9437	public:
9438
9439	Builder<STATE \| TargetIdSet>& setTargetId(const String& value)
9440	{
9441	COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set);
9442	m_result ->setString("targetId"_s, value);
9443	return castState<TargetIdSet>();
9444	}
9445
9446	Builder<STATE \| TypeSet>& setType(Type value)
9447	{
9448	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
9449	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
9450	return castState<TypeSet>();
9451	}
9452
9453	Ref<TargetInfo> release()
9454	{
9455	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9456	COMPILE_ASSERT(sizeof(TargetInfo) == sizeof(JSON::Object), cannot_cast);
9457
9458	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9459	auto result = WTFMove(*reinterpret_cast<Ref<TargetInfo>*>(&jsonResult));
9460	return result;
9461	}
9462	};
9463
9464	/*
9465	* Synthetic constructor:
9466	* Ref<TargetInfo> result = TargetInfo::create()
9467	* .setTargetId(...)
9468	* .setType(...)
9469	* .release();
9470	*/
9471	static Builder<NoFieldsSet> create()
9472	{
9473	return Builder<NoFieldsSet>(JSON::Object::create());
9474	}
9475	};
9476
9477	} // Target
9478
9479	namespace Timeline {
9480	/ Timeline record type. /
9481	enum class EventType {
9482	EventDispatch = `179`,
9483	ScheduleStyleRecalculation = `180`,
9484	RecalculateStyles = `181`,
9485	InvalidateLayout = `182`,
9486	Layout = `183`,
9487	Paint = `184`,
9488	Composite = `185`,
9489	RenderingFrame = `186`,
9490	TimerInstall = `187`,
9491	TimerRemove = `188`,
9492	TimerFire = `189`,
9493	EvaluateScript = `190`,
9494	TimeStamp = `191`,
9495	Time = `192`,
9496	TimeEnd = `193`,
9497	FunctionCall = `194`,
9498	ProbeSample = `195`,
9499	ConsoleProfile = `196`,
9500	RequestAnimationFrame = `197`,
9501	CancelAnimationFrame = `198`,
9502	FireAnimationFrame = `199`,
9503	ObserverCallback = `200`,
9504	}; // enum class EventType
9505	/ Instrument types. /
9506	enum class Instrument {
9507	ScriptProfiler = `201`,
9508	Timeline = `202`,
9509	CPU = `203`,
9510	Memory = `204`,
9511	Heap = `205`,
9512	}; // enum class Instrument
9513	/ Timeline record contains information about the recorded activity. /
9514	class TimelineEvent : public JSON::Object {
9515	public:
9516	enum {
9517	NoFieldsSet = `0`,
9518	TypeSet = `1` << `0`,
9519	DataSet = `1` << `1`,
9520	AllFieldsSet = (TypeSet \| DataSet)
9521	};
9522
9523	template<int STATE>
9524	class Builder {
9525	private:
9526	RefPtr<JSON::Object> m_result;
9527
9528	template<int STEP> Builder<STATE \| STEP>& castState()
9529	{
9530	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9531	}
9532
9533	Builder(Ref</TimelineEvent/JSON::Object>&& object)
9534	: m_result (WTFMove(object))
9535	{
9536	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9537	}
9538	friend class TimelineEvent;
9539	public:
9540
9541	Builder<STATE \| TypeSet>& setType(Inspector::Protocol::Timeline::EventType value)
9542	{
9543	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
9544	m_result ->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
9545	return castState<TypeSet>();
9546	}
9547
9548	Builder<STATE \| DataSet>& setData(RefPtr<JSON::Object> value)
9549	{
9550	COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set);
9551	m_result ->setObject("data"_s, value);
9552	return castState<DataSet>();
9553	}
9554
9555	Ref<TimelineEvent> release()
9556	{
9557	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9558	COMPILE_ASSERT(sizeof(TimelineEvent) == sizeof(JSON::Object), cannot_cast);
9559
9560	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9561	auto result = WTFMove(*reinterpret_cast<Ref<TimelineEvent>*>(&jsonResult));
9562	return result;
9563	}
9564	};
9565
9566	/*
9567	* Synthetic constructor:
9568	* Ref<TimelineEvent> result = TimelineEvent::create()
9569	* .setType(...)
9570	* .setData(...)
9571	* .release();
9572	*/
9573	static Builder<NoFieldsSet> create()
9574	{
9575	return Builder<NoFieldsSet>(JSON::Object::create());
9576	}
9577
9578	void setChildren(RefPtr<JSON::ArrayOf<Inspector::Protocol::Timeline::TimelineEvent>> value)
9579	{
9580	JSON::ObjectBase::setArray("children"_s, WTFMove(value));
9581	}
9582
9583	// Property names for type generated as open.
9584	JS_EXPORT_PRIVATE static const char* Type;
9585	JS_EXPORT_PRIVATE static const char* Data;
9586	JS_EXPORT_PRIVATE static const char* Children;
9587	};
9588
9589	} // Timeline
9590
9591	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::Location> {
9592	static void assertValueHasExpectedType(JSON::Value*);
9593	};
9594	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::FunctionDetails> {
9595	static RefPtr<Inspector::Protocol::Debugger::FunctionDetails> runtimeCast(RefPtr<JSON::Value>&& value);
9596	static void assertValueHasExpectedType(JSON::Value*);
9597	};
9598	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::CallFrame> {
9599	static RefPtr<Inspector::Protocol::Debugger::CallFrame> runtimeCast(RefPtr<JSON::Value>&& value);
9600	static void assertValueHasExpectedType(JSON::Value*);
9601	};
9602	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::Scope::Type> {
9603	static void assertValueHasExpectedType(JSON::Value*);
9604	};
9605	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::Scope> {
9606	static void assertValueHasExpectedType(JSON::Value*);
9607	};
9608	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::RemoteObject::Type> {
9609	static void assertValueHasExpectedType(JSON::Value*);
9610	};
9611	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::RemoteObject::Subtype> {
9612	static void assertValueHasExpectedType(JSON::Value*);
9613	};
9614	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::RemoteObject> {
9615	static RefPtr<Inspector::Protocol::Runtime::RemoteObject> runtimeCast(RefPtr<JSON::Value>&& value);
9616	static void assertValueHasExpectedType(JSON::Value*);
9617	};
9618	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::ObjectPreview::Type> {
9619	static void assertValueHasExpectedType(JSON::Value*);
9620	};
9621	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::ObjectPreview::Subtype> {
9622	static void assertValueHasExpectedType(JSON::Value*);
9623	};
9624	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::ObjectPreview> {
9625	static RefPtr<Inspector::Protocol::Runtime::ObjectPreview> runtimeCast(RefPtr<JSON::Value>&& value);
9626	static void assertValueHasExpectedType(JSON::Value*);
9627	};
9628	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::PropertyPreview::Type> {
9629	static void assertValueHasExpectedType(JSON::Value*);
9630	};
9631	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::PropertyPreview::Subtype> {
9632	static void assertValueHasExpectedType(JSON::Value*);
9633	};
9634	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::PropertyPreview> {
9635	static void assertValueHasExpectedType(JSON::Value*);
9636	};
9637	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::EntryPreview> {
9638	static void assertValueHasExpectedType(JSON::Value*);
9639	};
9640	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::CollectionEntry> {
9641	static RefPtr<Inspector::Protocol::Runtime::CollectionEntry> runtimeCast(RefPtr<JSON::Value>&& value);
9642	static void assertValueHasExpectedType(JSON::Value*);
9643	};
9644	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::PropertyDescriptor> {
9645	static RefPtr<Inspector::Protocol::Runtime::PropertyDescriptor> runtimeCast(RefPtr<JSON::Value>&& value);
9646	static void assertValueHasExpectedType(JSON::Value*);
9647	};
9648	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::InternalPropertyDescriptor> {
9649	static RefPtr<Inspector::Protocol::Runtime::InternalPropertyDescriptor> runtimeCast(RefPtr<JSON::Value>&& value);
9650	static void assertValueHasExpectedType(JSON::Value*);
9651	};
9652	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Timeline::EventType> {
9653	static void assertValueHasExpectedType(JSON::Value*);
9654	};
9655	template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Timeline::TimelineEvent> {
9656	static RefPtr<Inspector::Protocol::Timeline::TimelineEvent> runtimeCast(RefPtr<JSON::Value>&& value);
9657	static void assertValueHasExpectedType(JSON::Value*);
9658	};
9659
9660	namespace InspectorHelpers {
9661
9662	template<typename ProtocolEnumType>
9663	Optional<ProtocolEnumType> parseEnumValueFromString(const String&);
9664
9665	#if ENABLE(RESOURCE_USAGE)
9666	// Enums in the 'CPUProfiler' Domain
9667	template<>
9668	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CPUProfiler::ThreadInfo::Type> parseEnumValueFromString<Inspector::Protocol::CPUProfiler::ThreadInfo::Type>(const String&);
9669	#endif // ENABLE(RESOURCE_USAGE)
9670
9671	// Enums in the 'CSS' Domain
9672	template<>
9673	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CSS::StyleSheetOrigin> parseEnumValueFromString<Inspector::Protocol::CSS::StyleSheetOrigin>(const String&);
9674	template<>
9675	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CSS::PseudoId> parseEnumValueFromString<Inspector::Protocol::CSS::PseudoId>(const String&);
9676	template<>
9677	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CSS::CSSPropertyStatus> parseEnumValueFromString<Inspector::Protocol::CSS::CSSPropertyStatus>(const String&);
9678	template<>
9679	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CSS::CSSMedia::Source> parseEnumValueFromString<Inspector::Protocol::CSS::CSSMedia::Source>(const String&);
9680
9681	// Enums in the 'Canvas' Domain
9682	template<>
9683	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Canvas::ContextType> parseEnumValueFromString<Inspector::Protocol::Canvas::ContextType>(const String&);
9684	template<>
9685	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Canvas::ShaderType> parseEnumValueFromString<Inspector::Protocol::Canvas::ShaderType>(const String&);
9686
9687	// Enums in the 'Console' Domain
9688	template<>
9689	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Console::ChannelSource> parseEnumValueFromString<Inspector::Protocol::Console::ChannelSource>(const String&);
9690	template<>
9691	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Console::ChannelLevel> parseEnumValueFromString<Inspector::Protocol::Console::ChannelLevel>(const String&);
9692	template<>
9693	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Console::ConsoleMessage::Level> parseEnumValueFromString<Inspector::Protocol::Console::ConsoleMessage::Level>(const String&);
9694	template<>
9695	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Console::ConsoleMessage::Type> parseEnumValueFromString<Inspector::Protocol::Console::ConsoleMessage::Type>(const String&);
9696
9697	// Enums in the 'DOM' Domain
9698	template<>
9699	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::PseudoType> parseEnumValueFromString<Inspector::Protocol::DOM::PseudoType>(const String&);
9700	template<>
9701	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::ShadowRootType> parseEnumValueFromString<Inspector::Protocol::DOM::ShadowRootType>(const String&);
9702	template<>
9703	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::CustomElementState> parseEnumValueFromString<Inspector::Protocol::DOM::CustomElementState>(const String&);
9704	template<>
9705	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::LiveRegionRelevant> parseEnumValueFromString<Inspector::Protocol::DOM::LiveRegionRelevant>(const String&);
9706	template<>
9707	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::AccessibilityProperties::Checked> parseEnumValueFromString<Inspector::Protocol::DOM::AccessibilityProperties::Checked>(const String&);
9708	template<>
9709	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::AccessibilityProperties::Current> parseEnumValueFromString<Inspector::Protocol::DOM::AccessibilityProperties::Current>(const String&);
9710	template<>
9711	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::AccessibilityProperties::Invalid> parseEnumValueFromString<Inspector::Protocol::DOM::AccessibilityProperties::Invalid>(const String&);
9712	template<>
9713	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::AccessibilityProperties::LiveRegionStatus> parseEnumValueFromString<Inspector::Protocol::DOM::AccessibilityProperties::LiveRegionStatus>(const String&);
9714
9715	// Enums in the 'DOMDebugger' Domain
9716	template<>
9717	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOMDebugger::DOMBreakpointType> parseEnumValueFromString<Inspector::Protocol::DOMDebugger::DOMBreakpointType>(const String&);
9718	template<>
9719	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOMDebugger::EventBreakpointType> parseEnumValueFromString<Inspector::Protocol::DOMDebugger::EventBreakpointType>(const String&);
9720
9721	// Enums in the 'Debugger' Domain
9722	template<>
9723	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Debugger::BreakpointAction::Type> parseEnumValueFromString<Inspector::Protocol::Debugger::BreakpointAction::Type>(const String&);
9724	template<>
9725	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Debugger::Scope::Type> parseEnumValueFromString<Inspector::Protocol::Debugger::Scope::Type>(const String&);
9726
9727	// Enums in the 'Heap' Domain
9728	template<>
9729	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Heap::GarbageCollection::Type> parseEnumValueFromString<Inspector::Protocol::Heap::GarbageCollection::Type>(const String&);
9730
9731	#if ENABLE(INDEXED_DATABASE)
9732	// Enums in the 'IndexedDB' Domain
9733	template<>
9734	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::IndexedDB::Key::Type> parseEnumValueFromString<Inspector::Protocol::IndexedDB::Key::Type>(const String&);
9735	template<>
9736	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::IndexedDB::KeyPath::Type> parseEnumValueFromString<Inspector::Protocol::IndexedDB::KeyPath::Type>(const String&);
9737	#endif // ENABLE(INDEXED_DATABASE)
9738
9739	#if ENABLE(RESOURCE_USAGE)
9740	// Enums in the 'Memory' Domain
9741	template<>
9742	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Memory::CategoryData::Type> parseEnumValueFromString<Inspector::Protocol::Memory::CategoryData::Type>(const String&);
9743	#endif // ENABLE(RESOURCE_USAGE)
9744
9745	// Enums in the 'Network' Domain
9746	template<>
9747	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Network::Response::Source> parseEnumValueFromString<Inspector::Protocol::Network::Response::Source>(const String&);
9748	template<>
9749	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Network::Metrics::Priority> parseEnumValueFromString<Inspector::Protocol::Network::Metrics::Priority>(const String&);
9750	template<>
9751	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Network::Initiator::Type> parseEnumValueFromString<Inspector::Protocol::Network::Initiator::Type>(const String&);
9752
9753	// Enums in the 'Page' Domain
9754	template<>
9755	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::Setting> parseEnumValueFromString<Inspector::Protocol::Page::Setting>(const String&);
9756	template<>
9757	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::ResourceType> parseEnumValueFromString<Inspector::Protocol::Page::ResourceType>(const String&);
9758	template<>
9759	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::CoordinateSystem> parseEnumValueFromString<Inspector::Protocol::Page::CoordinateSystem>(const String&);
9760	template<>
9761	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::CookieSameSitePolicy> parseEnumValueFromString<Inspector::Protocol::Page::CookieSameSitePolicy>(const String&);
9762	template<>
9763	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::Appearance> parseEnumValueFromString<Inspector::Protocol::Page::Appearance>(const String&);
9764
9765	// Enums in the 'Recording' Domain
9766	template<>
9767	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Recording::Type> parseEnumValueFromString<Inspector::Protocol::Recording::Type>(const String&);
9768	template<>
9769	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Recording::Initiator> parseEnumValueFromString<Inspector::Protocol::Recording::Initiator>(const String&);
9770
9771	// Enums in the 'Runtime' Domain
9772	template<>
9773	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::SyntaxErrorType> parseEnumValueFromString<Inspector::Protocol::Runtime::SyntaxErrorType>(const String&);
9774	template<>
9775	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::RemoteObject::Type> parseEnumValueFromString<Inspector::Protocol::Runtime::RemoteObject::Type>(const String&);
9776	template<>
9777	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::RemoteObject::Subtype> parseEnumValueFromString<Inspector::Protocol::Runtime::RemoteObject::Subtype>(const String&);
9778	template<>
9779	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::ObjectPreview::Type> parseEnumValueFromString<Inspector::Protocol::Runtime::ObjectPreview::Type>(const String&);
9780	template<>
9781	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::ObjectPreview::Subtype> parseEnumValueFromString<Inspector::Protocol::Runtime::ObjectPreview::Subtype>(const String&);
9782	template<>
9783	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::PropertyPreview::Type> parseEnumValueFromString<Inspector::Protocol::Runtime::PropertyPreview::Type>(const String&);
9784	template<>
9785	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::PropertyPreview::Subtype> parseEnumValueFromString<Inspector::Protocol::Runtime::PropertyPreview::Subtype>(const String&);
9786
9787	// Enums in the 'ScriptProfiler' Domain
9788	template<>
9789	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::ScriptProfiler::EventType> parseEnumValueFromString<Inspector::Protocol::ScriptProfiler::EventType>(const String&);
9790
9791	// Enums in the 'Target' Domain
9792	template<>
9793	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Target::TargetInfo::Type> parseEnumValueFromString<Inspector::Protocol::Target::TargetInfo::Type>(const String&);
9794
9795	// Enums in the 'Timeline' Domain
9796	template<>
9797	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Timeline::EventType> parseEnumValueFromString<Inspector::Protocol::Timeline::EventType>(const String&);
9798	template<>
9799	JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Timeline::Instrument> parseEnumValueFromString<Inspector::Protocol::Timeline::Instrument>(const String&);
9800
9801	} // namespace InspectorHelpers
9802
9803	} // namespace Protocol
9804
9805	} // namespace Inspector
9806
9807	namespace WTF {
9808
9809	template<typename T> struct DefaultHash;
9810
9811	// Hash declarations in the 'CSS' Domain
9812	template<>
9813	struct DefaultHash<Inspector::Protocol::CSS::StyleSheetOrigin> {
9814	typedef IntHash<Inspector::Protocol::CSS::StyleSheetOrigin> Hash;
9815	};
9816	template<>
9817	struct DefaultHash<Inspector::Protocol::CSS::PseudoId> {
9818	typedef IntHash<Inspector::Protocol::CSS::PseudoId> Hash;
9819	};
9820	template<>
9821	struct DefaultHash<Inspector::Protocol::CSS::CSSPropertyStatus> {
9822	typedef IntHash<Inspector::Protocol::CSS::CSSPropertyStatus> Hash;
9823	};
9824
9825	// Hash declarations in the 'Canvas' Domain
9826	template<>
9827	struct DefaultHash<Inspector::Protocol::Canvas::ContextType> {
9828	typedef IntHash<Inspector::Protocol::Canvas::ContextType> Hash;
9829	};
9830	template<>
9831	struct DefaultHash<Inspector::Protocol::Canvas::ShaderType> {
9832	typedef IntHash<Inspector::Protocol::Canvas::ShaderType> Hash;
9833	};
9834
9835	// Hash declarations in the 'Console' Domain
9836	template<>
9837	struct DefaultHash<Inspector::Protocol::Console::ChannelSource> {
9838	typedef IntHash<Inspector::Protocol::Console::ChannelSource> Hash;
9839	};
9840	template<>
9841	struct DefaultHash<Inspector::Protocol::Console::ChannelLevel> {
9842	typedef IntHash<Inspector::Protocol::Console::ChannelLevel> Hash;
9843	};
9844
9845	// Hash declarations in the 'DOM' Domain
9846	template<>
9847	struct DefaultHash<Inspector::Protocol::DOM::PseudoType> {
9848	typedef IntHash<Inspector::Protocol::DOM::PseudoType> Hash;
9849	};
9850	template<>
9851	struct DefaultHash<Inspector::Protocol::DOM::ShadowRootType> {
9852	typedef IntHash<Inspector::Protocol::DOM::ShadowRootType> Hash;
9853	};
9854	template<>
9855	struct DefaultHash<Inspector::Protocol::DOM::CustomElementState> {
9856	typedef IntHash<Inspector::Protocol::DOM::CustomElementState> Hash;
9857	};
9858	template<>
9859	struct DefaultHash<Inspector::Protocol::DOM::LiveRegionRelevant> {
9860	typedef IntHash<Inspector::Protocol::DOM::LiveRegionRelevant> Hash;
9861	};
9862
9863	// Hash declarations in the 'DOMDebugger' Domain
9864	template<>
9865	struct DefaultHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> {
9866	typedef IntHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> Hash;
9867	};
9868	template<>
9869	struct DefaultHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> {
9870	typedef IntHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> Hash;
9871	};
9872
9873	// Hash declarations in the 'Page' Domain
9874	template<>
9875	struct DefaultHash<Inspector::Protocol::Page::Setting> {
9876	typedef IntHash<Inspector::Protocol::Page::Setting> Hash;
9877	};
9878	template<>
9879	struct DefaultHash<Inspector::Protocol::Page::ResourceType> {
9880	typedef IntHash<Inspector::Protocol::Page::ResourceType> Hash;
9881	};
9882	template<>
9883	struct DefaultHash<Inspector::Protocol::Page::CoordinateSystem> {
9884	typedef IntHash<Inspector::Protocol::Page::CoordinateSystem> Hash;
9885	};
9886	template<>
9887	struct DefaultHash<Inspector::Protocol::Page::CookieSameSitePolicy> {
9888	typedef IntHash<Inspector::Protocol::Page::CookieSameSitePolicy> Hash;
9889	};
9890	template<>
9891	struct DefaultHash<Inspector::Protocol::Page::Appearance> {
9892	typedef IntHash<Inspector::Protocol::Page::Appearance> Hash;
9893	};
9894
9895	// Hash declarations in the 'Recording' Domain
9896	template<>
9897	struct DefaultHash<Inspector::Protocol::Recording::Type> {
9898	typedef IntHash<Inspector::Protocol::Recording::Type> Hash;
9899	};
9900	template<>
9901	struct DefaultHash<Inspector::Protocol::Recording::Initiator> {
9902	typedef IntHash<Inspector::Protocol::Recording::Initiator> Hash;
9903	};
9904
9905	// Hash declarations in the 'Runtime' Domain
9906	template<>
9907	struct DefaultHash<Inspector::Protocol::Runtime::SyntaxErrorType> {
9908	typedef IntHash<Inspector::Protocol::Runtime::SyntaxErrorType> Hash;
9909	};
9910
9911	// Hash declarations in the 'ScriptProfiler' Domain
9912	template<>
9913	struct DefaultHash<Inspector::Protocol::ScriptProfiler::EventType> {
9914	typedef IntHash<Inspector::Protocol::ScriptProfiler::EventType> Hash;
9915	};
9916
9917	// Hash declarations in the 'Timeline' Domain
9918	template<>
9919	struct DefaultHash<Inspector::Protocol::Timeline::EventType> {
9920	typedef IntHash<Inspector::Protocol::Timeline::EventType> Hash;
9921	};
9922	template<>
9923	struct DefaultHash<Inspector::Protocol::Timeline::Instrument> {
9924	typedef IntHash<Inspector::Protocol::Timeline::Instrument> Hash;
9925	};
9926
9927	} // namespace WTF
9928

Browse the source code of webkit/WebKitBuild/Debug/DerivedSources/ForwardingHeaders/JavaScriptCore/InspectorProtocolObjects.h