The QRestBuilder Tool

Table of Contents

• What it does
• Getting Started
• File Syntax documentation
  • Element Type: RestObject (and RestGadget)
    • Attributes
    • Allowed Child Elements
  • Element Type: RestClass
    • Allowed Child Elements
  • Element Type: RestApi
    • Attributes
    • Allowed Child Elements
  • Element Type: RestAccess
    • Attributes
    • Allowed Child Elements
  • Element Type: Include
    • Attributes
    • Content
  • Element Type: BaseParam
    • Attributes
    • Content
  • Element Type: Property
    • Attributes
  • Element Type: PropertyMethod
    • Attributes
    • Content
  • Element Type: UserProperty
    • Attributes
    • Allowed Child Elements
  • Element Type: Enum
    • Attributes
    • Allowed Child Elements
  • Element Type: EnumKey
    • Attributes
    • Content
  • Element Type: Expression
    • Attributes
    • Content
  • Element Type: FixedParam
    • Attributes
  • Element Type: Class
    • Attributes
  • Element Type: PathGroup
    • generator_doc_PathGroup_children
  • Element Type: Method
    • Attributes
    • Allowed Child Elements
  • Element Type: BaseUrl
    • Attributes
• The XSD definition

The documentation for the qrestbuilder tool

What it does

The qrestbuilder reads in a xml file, and generates a header and a source from it. Those will, depending on the input, contain either an "object", "gadget", "class" or "api". This allows an easy and fast creation of wrappers for any REST-API. In order to use the tool as custom compiler, ou can simply create the XML files and add the to the pro file using

REST_API_FILES += # your xml files

Getting Started

The easiest way to get started is to check out the JsonPlaceholderApi example. It will teach you the general system behind the generator. You can then study this documentation to see, what you can do with it.

File Syntax documentation

The following sections show a detailed documentation of what you can do with the tool, and explain the syntax of the xml files. You can check the following locations for some sample files:

• README.md
• example/JsonPlaceholderApi
• tests/auto/restclient/RestBuilderTest

There are also W3C XML Schema definitions available, see tools/qrestbuilder/restclient.xsd (TODO also attached to the end of this page). Please note that while in the XSD sequences are used, generally the order of elements in the xml files can be whatever you want it to be. The only elements where the order actually has any effect are the <Path>/<PathParam> elements of the <Method> element - but this is specified in more detail in their documentation.

Your document must start with one of the following 4 root elements:

• <RestObject> - will generate an api object based on QObject
• <RestGadget> - will generate an api object based on Q_GADGET
• <RestClass> - will generate an api subclass
• <RestApi> - will generate the api root class
  

An object is simply a "data type" class. It will be generated with a bunch of properties (Q_PROPERTY), and methods to access them. They are generated in an optimized way, an can be used by the rest client as data classes. It allows a simple, fast and easy creation of those objects. You can generate them in two ways: As a Q_GADGET or a QObject. The gadget has the advantage of beeing a value type and using shared data, but on the other side does not really allow inheritance and does not support change signals or dynamic properties, which the QObject classes do.

A class is a wrapper around QtRestClient::RestClass, that encapsulates the rather generic methods into custom methods with adjusted parameters etc. This creates a c++ class, with simple methods to do HTTP-Request. In addition to that, you can build hieracical trees with classes, and those are represented by methods in the classes, allowing you to follow that tree in c++ as well. For the "root-class", you can use the api version, which allows you to specify the basic properties of a QtRestClient::RestClient.

Element Type: RestObject (and RestGadget)

The RestObject and RestGadget elements are of the same datatype and thus support the same attributes and children. The only difference is how the final c++ code is beeing generated.

Attributes

Name	Allowed values	Default/Required	Description
name	c++ class name	required	The class name of the generated class
export	string	none	Sepcify an export macro. The value is put before the class definition, if you want to export the generated classes from a dynamic library
base	name of a base class	"QObject" for objects, "" for gadgets	If you need a custom base class, use this property
namespace	c++ namespace name	none	An optional namespace to place the generated objects into
registerConverters	bool	true	If true, automatically registers the list converters for this type
testEquality	bool	true	Setter methods check if the value did actually change before assigning it. This can fail if a used type does not have equality operators.
generateEquals	bool	true for RestGadget, else false	If enabled, default-generated equality operators are added
generateReset	bool	true	If enabled, reset methods are generated for all properties. Can still be set per property
simpleHref	c++ property name	none	Optional name of the property that holds the href to extend a simple object. Can only be used if base is or extends QtRestClient::Simple
qmlUri	qml import URI	none	A QML import URI (+version), e.g. "com.example.api 1.0" - If specified, QML bindings are generated for the object/gadget
aggregateDefaults	bool	false	Specifies whether the generated aggregate constructor should have default values for all arguments after the second or not

Allowed Child Elements

Name	XML-Type	Limits	Description
Include	Include	0 - ∞	Additional header files to be included in the generated header
Enum	Enum	0 - ∞	Custom enums to be created as part of the generated class
Property	Property	1 - ∞	The actual properties the class is composed of

Element Type: RestClass

This class is an extension of RestAccess. This means all the attributes and allowed child elements of RestAccess can/must also be used for a RestClass, include the additional attributes and child elements defined here.

The rest class is a sub class that is a part of a greater api.

Allowed Child Elements

Name	XML-Type	Limits	Description
Path	Expression	0 - 1	The sub-path of this class, relative to it's parent class/api (QString)

Element Type: RestApi

This class is an extension of RestAccess. This means all the attributes and allowed child elements of RestAccess can/must also be used for a RestClass, include the additional attributes and child elements defined here.

The rest api is basically a root class with additional properties to create the apis root RestClient.

Attributes

Name	Allowed values	Default/Required	Description
globalName	string	none	The APIs global name. If specified the api is made available globally by using QtRestClient::addGlobalApi with that name
dataMode	QtRestClient::RestClient::DataMode	"Json"	Sets the QtRestClient::RestClient::dataMode to the given value
threaded	bool	true if globalName is set, else false	Sets the QtRestClient::RestClient::threaded to the given value
async	bool	true if globalName is set, else false	Sets the QtRestClient::RestClient::asyncPool to the default QThreadPool::globalInstance. Implies threaded
autoCreate	bool	true if globalName is set, else false	Requires globalName to be set. If set to true, the API will be automatically registered on application start. If not, it happens on first use

Allowed Child Elements

Name	XML-Type	Limits	Description
BaseUrl	BaseUrl	1	The primary base URL for the api to base all subpaths on (required)
Parameter	FixedParam	0 - ∞	Additional URL query parameters to be added to the base URL
Header	FixedParam	0 - ∞	Additional HTTP-Headers to be added to every HTTP request

Element Type: RestAccess

This type is a virtual type that you will never use directly. Instead is serves as a base class for RestApi and RestClass. All the attributes and children defined here can/must be used on those two element types.

Attributes

Name	Allowed values	Default/Required	Description
name	c++ class name	required	The class name of the generated class
export	string	none	Sepcify an export macro. The value is put before the class/factory definition, if you want to export the generated classes from a dynamic library
base	name of a base class	"QObject"	If you need a custom base class, use this property
namespace	c++ namespace name	none	An optional namespace to place the generated objects into
except	c++ class name	"Object*"	The default value for "except" of all Method Elementshappens on first use
qmlUri	qml import URI	none	A QML import URI (+version), e.g. "com.example.api 1.0" - If specified, QML bindings are generated for the class/api

Allowed Child Elements

Name	XML-Type	Limits	Description
Include	Include	0 - ∞	Additional header files to be included in the generated header
Class	Class	0 - ∞	The child classes to generate methods for
Method	Method	0 - ∞	The Actual REST-Methods to access the api within the current class

Element Type: Include

Describes a file to be included via a c++ include directive. You can use them if you want to make use of special classes in your generated classes. Both global includes (#include <header>) and local includes (#include "header") are supported

Attributes

Name	Allowed values	Default/Required	Description
local	bool	false	Specifies whether the include is a global or a local include

Content

The content of this element must be a string. More specific the header to be included. It becomes the content of the include directive. Specifiy it without the braces or quores, as thoes are added automatically.

Element Type: BaseParam

A base param is a method parameter or a Q_PROPERTY to be added to the generated class/method. For each such property, getters and setters are generated as well, and depending on the configuration even notify signals and reset methods. For method parameters, it determines the name and type of the parameter, as well as the parameters default value, if wanted.

Attributes

Name	Allowed values	Default/Required	Description
key	property/parameter name	required	The property or parameter name
type	c++ type name	required	The properties/parameters type
asStr	bool	false	Specify how the element content should be interpreted

Content

The content of a base param is optional, and it represents the default value of the property/parameter. If not specified, the base param will be initialize with it's default constructor. If specified, the content is used to initialize (and reset) the base param. How the content is interpreted depends on the asStr attribute.

If it is set to false (the default), the content must be c++ code and is copied to the generated class as is. The code must be an expression that evalutes to a single value that is implicitly convertible to the given type. If type was for example int, valid expressions could be:

• <BaseParam>-1</BaseParam>
• <BaseParam>10 + 20</BaseParam>
• <BaseParam>qRand()</BaseParam>

If set to true, the content is assumed to be a string. You don't need to specify quotation marks around the string. That string is used to initialize a QVariant that is then converted to type - in other words, the type you use must be variant convertible from a string. This can be used to, for example, create a QDate from a string with the default value of <BaseParam asStr="true">2018-05-09</BaseParam>.

Element Type: Property

The Property element is an extension of the BaseParam type. This means it's the same as a base param, but with an addition property, that is specific to properties.

Attributes

Name	Allowed values	Default/Required	Description
generateReset	bool	RestObject.generateReset	Specify whether a reset accessor method should be generated. This value is inherited from the one specified in the parent rest object or gadget. If that one is not specified, the default is true
metaType	c++ type name	BaseParam.type	Set an extra type to use for the declaration of properties and their accessors. Can become useful if a type was registered in the metasystem under a different typename then it's canonical name
revision	int	none	Add the REVISION attribute to the properties declaration
designable	bool	none	Add the DESIGNABLE attribute to the properties declaration
scriptable	bool	none	Add the SCRIPTABLE attribute to the properties declaration
stored	bool	none	Add the STORED attribute to the properties declaration
user	bool	none	Add the USER attribute to the properties declaration
final	bool	false	Add the FINALS attribute to the properties declaration if set to true

Element Type: PropertyMethod

The PropertyMethod element allows you to declare custom methods for UserProperties. The attributes of this element differ slightly, depending on whether it's a read, write, reset or notify method.

Attributes

Name	Allowed values	Default/Required	Accessors	Description
name	c++ method name	required	all	The c++ name of the generated method
virtual	bool	false	read, write, reset	Make the generated method virtual
invokable	bool	false	read	Make the generated method Q_INVOKABLE
parameter	c++ variable name	"value"	write	Specify a custom name for the setters parameter
declare	bool	true	notify	If set to false, the signal will not be declared

Content

Only methods for the read, write and reset accessor are allowed a content. That content is the definition of the method to be generated. If specified, both the declaration and the definition are generated. If left empty, neither are. For signals, only declarations are needed, as MOC generates the definition. Use the declare attribute there to control this behaviour.

Element Type: UserProperty

A special form of a property where you must specify your own methods, instead of automatically generating them based of their type and name.

Attributes

Name	Allowed values	Default/Required	Description
key	property name	required	The property name
type	c++ type name	required	The property type
metaType	c++ type name	type	Set an extra type to use for the declaration of properties and their accessors. Can become useful if a type was registered in the metasystem under a different typename then it's canonical name
member	c++ variable name	key	The name of the member variable to store the properties data. You can access it in the accessors via d-><member>
revision	int	none	Add the REVISION attribute to the properties declaration
designable	bool	none	Add the DESIGNABLE attribute to the properties declaration
scriptable	bool	none	Add the SCRIPTABLE attribute to the properties declaration
stored	bool	none	Add the STORED attribute to the properties declaration
user	bool	none	Add the USER attribute to the properties declaration
final	bool	false	Add the FINALS attribute to the properties declaration if set to true

Allowed Child Elements

Name	XML-Type	Limits	Description
Read	PropertyMethod	1	The method for the READ-accessor
Write	PropertyMethod	0 - 1	The method for the WRITE-accessor
Reset	PropertyMethod	0 - 1	The method for the RESET-accessor
Notify	PropertyMethod	0 - 1	The method for the NOTIFY-accessor
Default	Expression	0 - 1	The default value of the property

Element Type: Enum

If you want to use custom enum types in you class, use this element. It allows you to generate enums and flags that are automatically registered with Qt.

Attributes

Name	Allowed values	Default/Required	Description
name	c++ class name	required	The c++ name of the generated enum
base	name of a valid parent class	none	If you need a custom base class for your enum, use this property. But remember that Qt discourages this!
isFlags	bool	false	If set to true, a QFlag type is generated and registered instead of a normal enum
isClass	bool	false	If set to true, a enum class get created instead of a normal enum

Allowed Child Elements

Name	XML-Type	Limits	Description
Key	EnumKey	1 - ∞	The actual elements of the enum/flags to be generated

Element Type: EnumKey

Describes a key/element within an enum.

Attributes

Name	Allowed values	Default/Required	Description
name	c++ enum key name	required	The name of the key, i.e. the actual enum key.

Content

The content is optional. You can specify a custom value for your enum element (is placed after the = sign). The content must be a valid c++ constexpr, i.e. code that can be evaluated at compile time and that results in a value of the base type your enum is of (Or int, if no base type is given).

Element Type: Expression

An expression can be any arbitrary element. It is defined as s string, that can optionally be a c++ expression that evaluates to a string instead.

Attributes

Name	Allowed values	Default/Required	Description
expr	bool	false	Specify whether a string or an expression is given.

Content

The content is the actual string to be returned. If expr is false (the default), the content is the final string (excluding the sourrounding quotation marks), for example <Expression>42</Expression>. However, if it is set to true, then the content of this element is interpreted as a c++ expression. The expression must evaluate to a single result that is implicitly convertible to either QString or QByteArray, depending on the context it is beeing used in. A simple example for an expression would be: <Expression expr="true">QString::number(42)</Expression>

Element Type: FixedParam

A FixedParam is basically an Expression with an additional attribute, key, to give the expression an identity. So besides that extra attribute, it behaves just like an expression.

Attributes

Name	Allowed values	Default/Required	Description
key	string	required	The name/key of the parameter you are specifying

Element Type: Class

A class element is simply a reference to another RestClass to be made avilable as subclass of the current class/api. You will have to add the class type it as include. The type must be class generated by the tool as well. It is possible to use an api as child class as well, but it will ignore the API-aspect, and simply interpret it as class. However, it is not recommended to do so.

Attributes

Name	Allowed values	Default/Required	Description
key	c++ method name	required	The name of the method that returns the class
type	c++ class name	required	The type of the class to return by the method

Element Type: PathGroup

Encapsulates a parameterized path. This item is a mixed element. If the content is string content, it behaves like a Element Type: Expression. Alternatively, you can use the elements listed below to create a partially paramterized path.

generator_doc_PathGroup_children

The following elements can be specified in any order. They are combined to a single path where each of the child elements represents one part of the path, all seperated by a slash.

Name	XML-Type	Limits	Description
FixedSegment	Expression	0 - ∞	A fixed path segment to be added to the requests url path
ParamSegment	BaseParam	0 - ∞	A path segment as method parameter to be added to the requests url path

Element Type: Method

The main aspect of your class are the methods. They define what can be done by your class. They define a HTTP-request, that will be wrapped into a c++ method by the builder.

Attributes

Name	Allowed values	Default/Required	Description
name	c++ method name	required	The name of the method to be generated
verb	string (HTTP verb)	"GET"	The HTTP-Verb to be used for the request
body	c++ class name	none	An optional body, to be sent with the request. Must be serializable and included
returns	c++ class name	void	The type of the reply entity. Must be serializable and included, or void
except	c++ class name	RestAccess.except	The type of a reply with an error. Must be serializable and included. Defaults to the classes except property
postParams	bool	verb == "POST"	Specify if the <Param> elements should be send as URL query or POST parameter.

Allowed Child Elements

Name	XML-Type	Limits	Description
Path	PathGroup	0 - 1	A path to be added relative to the class sub url
Url	Expression	0 - 1	A fixed URL to be resolved relative to the classes sub URL
Param	BaseParam	0 - ∞	Additional method parameters to be used as query or past params for the request (Depending on postParams)
Header	FixedParam	0 - ∞	Additional HTTP-Headers to be added to the HTTP-Request

Attention

You cannot combine <Path> with <Url>. Either you use a of <Path> element to build a combine path from them, or you use a single <Url> to specify a whole, unparametrized, absolute URL. You can of cause specify neither as well.

Element Type: BaseUrl

A BaseUrl is basically an Expression with an additional attribute, apiVersion, to give the URL an optional, C++-validated version number, which can be accessed via the RestClient. So besides that extra attribute, it behaves just like an expression.

Attributes

Name	Allowed values	Default/Required	Description
apiVersion	QVersionNumber string	none	An optional API version to be appended to the base URL as extra path segment

The XSD definition

The following file is the XSD the builder operates on. You can use it to verify your rest api xml files.

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns:qxg="https://skycoder42.de/xml/schemas/QXmlCodeGen">
    <!-- QXG Definitions -->
    <qxg:config class="RestBuilderXmlReader"
                stdcompat="true"
                schemaUrl="qrc:/schemas/qrestbuilder.xsd">
    </qxg:config>
 
    <!-- Shared datatypes -->
    <xs:complexType name="Include">
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="local" type="xs:boolean" use="optional" default="false"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:attributeGroup name="TypedVariableAttribs">
        <xs:attribute name="key" type="xs:string" use="required"/>
        <xs:attribute name="type" type="xs:string" use="required"/>
    </xs:attributeGroup>
    <xs:complexType name="BaseParam">
        <xs:simpleContent>
            <xs:extension base="xs:string" qxg:member="defaultValue">
                <xs:attributeGroup ref="TypedVariableAttribs" qxg:inherit="true"/>
                <xs:attribute name="asStr" type="xs:boolean" use="optional" default="false"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="Expression">
        <xs:simpleContent>
            <xs:extension base="xs:string" qxg:member="value">
                <xs:attribute name="expr" type="xs:boolean" use="optional" default="false"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="FixedParam">
        <xs:simpleContent>
            <xs:extension base="Expression">
                <xs:attribute name="key" type="xs:string" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
 
    <!-- object/gadget types -->
    <xs:complexType name="EnumKey">
        <xs:simpleContent>
            <xs:extension base="xs:string" qxg:member="value">
                <xs:attribute name="name" type="xs:string" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="Enum">
        <xs:sequence>
            <xs:element maxOccurs="unbounded" minOccurs="1" name="Key" type="EnumKey" qxg:member="keys"/>
        </xs:sequence>
        <xs:attribute name="name" type="xs:string" use="required"/>
        <xs:attribute name="base" type="xs:string" use="optional" default="int"/>
        <xs:attribute name="isFlags" type="xs:boolean" use="optional" default="false"/>
        <xs:attribute name="isClass" type="xs:boolean" use="optional" default="true"/>
    </xs:complexType>
    <xs:attributeGroup name="PropertyAttribs">
        <xs:attribute name="metaType" type="xs:string" use="optional"/>
        <xs:attribute name="revision" type="xs:int" use="optional"/>
        <xs:attribute name="designable" type="xs:boolean" use="optional"/>
        <xs:attribute name="scriptable" type="xs:boolean" use="optional"/>
        <xs:attribute name="stored" type="xs:boolean" use="optional"/>
        <xs:attribute name="user" type="xs:boolean" use="optional"/>
        <xs:attribute name="final" type="xs:boolean" use="optional" default="false"/>
    </xs:attributeGroup>
    <xs:complexType name="Property">
        <xs:simpleContent>
            <xs:extension base="BaseParam">
                <xs:attributeGroup ref="PropertyAttribs" qxg:inherit="true"/>
                <xs:attribute name="generateReset" type="xs:boolean" use="optional" default="false"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
 
    <xs:complexType name="PropertyMethod">
        <xs:simpleContent>
            <xs:extension base="xs:string" qxg:member="definition">
                <xs:attribute name="name" type="xs:string" use="required"/>
                <xs:attribute name="virtual" type="xs:boolean" use="optional" qxg:member="isVirtual" default="false"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="PropertyReadMethod">
        <xs:simpleContent>
            <xs:extension base="PropertyMethod">
                <xs:attribute name="invokable" type="xs:boolean" use="optional" default="false"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="PropertyWriteMethod">
        <xs:simpleContent>
            <xs:extension base="PropertyMethod">
                <xs:attribute name="parameter" type="xs:string" use="optional" default="value"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="PropertySignal">
        <xs:attribute name="name" type="xs:string" use="required"/>
        <xs:attribute name="declare" type="xs:boolean" use="optional" default="true"/>
    </xs:complexType>
    <xs:complexType name="UserProperty">
        <xs:sequence>
            <xs:element maxOccurs="1" minOccurs="1" name="Read" type="PropertyReadMethod"/>
            <xs:element maxOccurs="1" minOccurs="0" name="Write" type="PropertyWriteMethod"/>
            <xs:element maxOccurs="1" minOccurs="0" name="Reset" type="PropertyMethod"/>
            <xs:element maxOccurs="1" minOccurs="0" name="Notify" type="PropertySignal"/>
            <xs:element maxOccurs="1" minOccurs="0" name="Default" type="Expression" qxg:member="defaultValue"/>
        </xs:sequence>
        <xs:attributeGroup ref="TypedVariableAttribs" qxg:inherit="true"/>
        <xs:attribute name="member" type="xs:string" use="optional"/>
        <xs:attributeGroup ref="PropertyAttribs" qxg:inherit="true"/>
    </xs:complexType>
 
    <xs:complexType name="RestContent">
        <xs:sequence>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="Include" type="Include" qxg:member="includes"/>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="Enum" type="Enum" qxg:member="enums"/>
            <xs:choice maxOccurs="unbounded" minOccurs="1" qxg:member="properties">
                <xs:element name="Property" type="Property" />
                <xs:element name="UserProperty" type="UserProperty" />
            </xs:choice>
        </xs:sequence>
        <xs:attribute name="name" type="xs:string" use="required"/>
        <xs:attribute name="base" type="xs:string" use="optional"/>
        <xs:attribute name="export" type="xs:string" use="optional" qxg:member="exportKey"/>
        <xs:attribute name="qmlUri" type="xs:string" use="optional"/>
        <xs:attribute name="registerConverters" type="xs:boolean" use="optional" default="true"/>
        <xs:attribute name="testEquality" type="xs:boolean" use="optional" default="true"/>
        <xs:attribute name="generateEquals" type="xs:boolean" use="optional"/>
        <xs:attribute name="generateReset" type="xs:boolean" use="optional" default="true"/>
        <xs:attribute name="namespace" type="xs:string" use="optional" qxg:member="nspace"/>
        <xs:attribute name="simpleHref" type="xs:string" use="optional"/>
        <xs:attribute name="aggregateDefaults" type="xs:boolean" use="optional" default="false"/>
    </xs:complexType>
 
    <xs:complexType name="RestObject">
        <xs:complexContent>
            <xs:extension base="RestContent" />
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="RestGadget">
        <xs:complexContent>
            <xs:extension base="RestContent" />
        </xs:complexContent>
    </xs:complexType>
 
 
    <!-- class/api types -->
    <xs:complexType name="PathGroup" mixed="true" qxg:member="path">
        <xs:sequence>
            <xs:choice maxOccurs="unbounded" minOccurs="0" qxg:member="segments">
                <xs:element name="FixedSegment" type="Expression"/>
                <xs:element name="ParamSegment" type="BaseParam"/>
            </xs:choice>
        </xs:sequence>
        <xs:attribute name="expr" type="xs:boolean" use="optional" default="false"/>
    </xs:complexType>
 
    <xs:complexType name="Class">
        <xs:attribute name="key" type="xs:string" use="required"/>
        <xs:attribute name="type" type="xs:string" use="required"/>
    </xs:complexType>
    <xs:complexType name="Method">
        <xs:sequence>
            <xs:choice maxOccurs="1" minOccurs="0" qxg:member="path">
                <xs:element name="Path" type="PathGroup"/>
                <xs:element name="Url" type="Expression"/>
            </xs:choice>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="Param" type="BaseParam" qxg:member="params"/>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="Header" type="FixedParam" qxg:member="headers"/>
        </xs:sequence>
        <xs:attribute name="name" type="xs:string" use="required"/>
        <xs:attribute name="verb" type="xs:string" use="optional" default="GET"/>
        <xs:attribute name="body" type="xs:string" use="optional"/>
        <xs:attribute name="returns" type="xs:string" use="optional" default="void"/>
        <xs:attribute name="except" type="xs:string" use="optional"/>
        <xs:attribute name="postParams" type="xs:boolean" use="optional"/>
    </xs:complexType>
 
    <xs:group name="RestAccessElements">
        <xs:sequence>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="Class" type="Class" qxg:member="classes"/>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="Method" type="Method" qxg:member="methods"/>
        </xs:sequence>
    </xs:group>
 
    <xs:complexType name="RestAccess">
        <xs:sequence>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="Include" type="Include" qxg:member="includes"/>
        </xs:sequence>
        <xs:attribute name="name" type="xs:string" use="required"/>
        <xs:attribute name="export" type="xs:string" use="optional" qxg:member="exportKey"/>
        <xs:attribute name="qmlUri" type="xs:string" use="optional"/>
        <xs:attribute name="base" type="xs:string" use="optional" default="QObject"/>
        <xs:attribute name="except" type="xs:string" use="optional" default="QObject*"/>
        <xs:attribute name="namespace" type="xs:string" use="optional" qxg:member="nspace"/>
    </xs:complexType>
 
    <!-- class only types -->
    <xs:complexType name="RestClass">
        <xs:complexContent>
            <xs:extension base="RestAccess">
                <xs:sequence>
                    <xs:element maxOccurs="1" minOccurs="0" name="Path" type="Expression"/>
                    <xs:group ref="RestAccessElements" qxg:inherit="true"/>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
 
    <!-- API only types -->
    <xs:complexType name="BaseUrl">
        <xs:simpleContent>
            <xs:extension base="Expression">
                <xs:attribute name="apiVersion" type="xs:string" use="optional"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:simpleType name="DataMode">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Cbor"/>
            <xs:enumeration value="Json"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="RestApi">
        <xs:complexContent>
            <xs:extension base="RestAccess">
                <xs:sequence>
                    <xs:element maxOccurs="1" minOccurs="0" name="Authenticator" type="xs:string"/>
                    <xs:element maxOccurs="1" minOccurs="1" name="BaseUrl" type="BaseUrl"/>
                    <xs:element maxOccurs="unbounded" minOccurs="0" name="Parameter" type="FixedParam" qxg:member="params"/>
                    <xs:element maxOccurs="unbounded" minOccurs="0" name="Header" type="FixedParam" qxg:member="headers"/>
                    <xs:group ref="RestAccessElements" qxg:inherit="true"/>
                </xs:sequence>
                <xs:attribute name="globalName" type="xs:string" use="optional"/>
                <xs:attribute name="dataMode" type="DataMode" use="optional" default="Json"/>
                <xs:attribute name="threaded" type="xs:boolean" use="optional" default="false"/>
                <xs:attribute name="async" type="xs:boolean" use="optional" default="false"/>
                <xs:attribute name="autoCreate" type="xs:boolean" use="optional" default="true"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
 
    <!-- root elements-->
    <xs:element name="RestObject" type="RestObject"/>
    <xs:element name="RestGadget" type="RestGadget"/>
    <xs:element name="RestClass" type="RestClass"/>
    <xs:element name="RestApi" type="RestApi"/>
</xs:schema>