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

Browse the source code of jsc/WebKitBuild/Debug/DerivedSources/JavaScriptCore/inspector/InspectorProtocolObjects.h