Swagger.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  Swagger.qm Copyright (C) 2017 - 2024 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
 
// make sure we have the required qore version
 
// try importing JSON and YAML modules
 
 
 
 
 
 
namespace Swagger {
const LM_IGNORE_MISSING_REQUIRED    = (1 << 0);
 
const LM_LAX_COLLECTIONFORMAT       = (1 << 1);
 
const LM_IGNORE_INVALID_REQUIRED    = (1 << 2);
 
const LM_ACCEPT_INVALID_BODY_PARAMS = (1 << 3);
 
const LM_AUTO_FORM_DATA             = (1 << 4);
 
const LM_OPTIONAL_REF_PROPERTIES    = (1 << 5);
 
const LM_ACCEPT_ALL_PROPERTIES      = (1 << 6);
 
const LM_ACCEPT_QUERY_OBJECTS       = (1 << 7);
 
const LM_IGNORE_INVALID_PATHS       = (1 << 8);
 
const LM_ALL = ...;
 
 
const ValidIntFormats = ("int32", "int64", "unix-time");
const ValidNumberFormats = ("double", "float");
const ValidStringFormats = ("binary", "byte", "date", "password", "unix-time");
 
const CollectionFormats = ...;
 
 
const ParameterCollectionFormats = ...;
 
 
const ValidIntFormatsHash = map {$1: True}, ValidIntFormats;
const ValidNumberFormatsHash = map {$1: True}, ValidNumberFormats;
const ValidStringFormatsHash = map {$1: True}, ValidStringFormats;
 
const YamlSerialization = ...;
 
 
const JsonSerialization = ...;
 
 
const MimeDataTypes = ...;
 
 
const SerializationModules = keys (map {$1.module: True}, MimeDataTypes.iterator(), $1.module);
 
const MimeContentTypes = keys MimeDataTypes;
 
const ValidSchemes = ("http", "https", "ws", "wss");
const ValidSchemesHash = map {$1: True}, ValidSchemes;
 
class ObjectBase : public Qore::Serializable {
 
public:
 
        hash<auto> vendorExtensions;
 
    constructor();
 
 
 
    constructor(hash<auto> oh);
 
 
    constructor(ObjectBase other);
 
 
 
     initialize(hash<auto> oh);
};
 
class SchemaBase : public Qore::Serializable {
 
public:
        *softfloat maximum;
 
        *softfloat minimum;
 
        *bool exclusiveMax;
 
        *bool exclusiveMin;
 
        *int maxLength;
 
        *int minLength;
 
        *string pattern;
 
        *int maxItems;
 
        *int minItems;
 
        *bool uniqueItems;
 
 
        hash<string, bool> enum;
 
        *float multipleOf;
 
 
    constructor(string objType, hash<auto> oh);
 
 
    constructor(SchemaBase other);
 
 
protected:
     constructor();
public:
 
 
protected:
     auto getExampleValueWithFormat(string type, *string format, *string fname);
public:
 
 
protected:
     check(bool serialize, bool request, string type, *string format, *SchemaObject items, string path, string method, string name, reference<auto> value);
public:
 
 
protected:
     checkStringIntern(string path, string method, string name, string value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, list<auto> v, reference<list> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, hash<auto> v, reference<hash> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, int v, reference<auto> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, number v, reference<number> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, float v, reference<number> value);
public:
 
 
protected:
     checkInternNumber(bool serialize, bool request, string type, *string format, string path, string method, string name, auto v, reference<auto> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, binary v, reference value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, string v, reference<auto> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, date v, reference<auto> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, bool v, reference<bool> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, nothing v, reference<nothing> value);
public:
 
 
protected:
     checkArrayParam(bool serialize, bool request, SchemaObject items, string path, string method, string name, reference<list<auto>> value);
public:
 
 
protected:
      static throwInvalidType(string name, string actual, string expected, auto value);
public:
 
 
 
      static bool checkValueType(reference<auto> value, string type);
};
 
class SwaggerLoader {
 
public:
 
      static SwaggerSchema fromString(string swaggerSpecification, *bool json, *hash<auto> opts);
 
 
      static SwaggerSchema fromFile(string filepath, *hash<auto> opts);
 
 
      static SwaggerSchema fromUrl(string url, *bool json, *hash<auto> opts);
 
 
      static hash<auto> parseSchemaContent(string filepath, string str);
 
      static hash<auto> parseSchemaSource(string str, string ser);
 
      static string detectSourceEncoding(string str);
};
 
class ParameterGroup : public ObjectBase {
 
public:
 
        hash<string, AbstractParameterObject> parameters();
 
        string query_obj;
 
    constructor(hash<auto> oh) ;
 
 
    addParameter(AbstractParameterObject p);
 
 
    addParameter(string key, AbstractParameterObject p);
 
};
 
class SwaggerSchema : public ParameterGroup, public AbstractRestSchemaValidator {
 
public:
 
        string swaggerSpec;
 
        InfoObject info;
 
        PathsObject paths;
 
 
        *string host;
 
 
        *string basePath;
 
 
        hash<string, bool> schemes;
 
 
        hash<string, bool> consumes;
 
 
        hash<string, bool> produces;
 
 
        hash<string, SchemaObject> definitions();
 
 
        hash<string, ResponseObject> responses;
 
 
        hash<string, SecuritySchemeObject> securityDefinitions;
 
 
        hash<string, softlist<string>> security;
 
 
        list<TagObject> tags;
 
        hash<auto> store;
 
        *ExternalDocumentationObject externalDocs;
 
 
        const SwaggerOptions = ...;
 
 
protected:
        bool compact_serialization;
 
        *string def_path;
 
 
        *code try_import;
 
        string hash_str;
 
        *int opt_flags;
 
        *softbool utc_dates;
 
        *string query_date_format;
 
        hash<string, hash<string, SchemaObject>> so_map;
 
        hash<string, hash<string, AbstractDataProviderType>> typemap;
 
public:
 
private:
        *hash<auto> source_definition_hash;
 
public:
 
 
    constructor(string schema_source, hash<auto> oh, *hash<auto> opts) ;
 
 
 
    constructor(LoggerInterface logger, string schema_source, hash<auto> oh, *hash<auto> opts) ;
 
 
protected:
     constructorIntern(string schema_source, hash<auto> oh, *hash<auto> opts);
public:
 
 
    *int getParseFlags();
 
 
    *bool getUtcDates();
 
 
    *string getQueryDateFormat();
 
 
    *SchemaObject tryGetSchemaObject(string name, hash<auto> oh, reference<string> hash_str);
 
 
    cacheSchemaObject(string name, string hash_str, SchemaObject so);
 
 
 
    SchemaObject resolveSchemaObject(string name, string refstr, hash<auto> oh);
 
 
 
    ParameterItemsSchemaObject resolveParameterItemsSchemaObject(string name, string refstr, hash<auto> oh, *string inLoc);
 
 
 
    AbstractParameterObject resolveParameter(string name, string refstr, hash<auto> oh);
 
 
 
    ResponseObject resolveResponse(string name, string refstr, hash<auto> oh);
 
 
    AbstractDataProviderType getTypeForReference(string rstr, bool required = True, *HTTPClient rest);
 
 
    replaceTypeForReference(string rstr, AbstractDataProviderType t);
 
 
    AbstractDataProviderType getType(string path, string typestr, *string format, *SchemaObject arrayItems, bool required = True);
 
 
protected:
     *AbstractDataProviderType checkType(string path, string typestr, *string format, *SchemaObject arrayItems, bool required = True, reference<string> id);
public:
 
 
protected:
     AbstractDataProviderType getTypeIntern(string path, string typestr, *string format, *SchemaObject arrayItems, bool required = True);
public:
 
 
    AbstractDataProviderType getSchemaDataType(string path, SchemaObject schema, bool required = True, *HTTPClient rest);
 
 
    AbstractDataField getFieldFromSchema(string name, *string desc, SchemaObject schema, bool required = True, *HTTPClient rest);
 
 
    addFieldsFromParameters(HashDataType rv, hash<string, AbstractParameterObject> parameters, reference<bool> required);
 
 
    AbstractDataField getFieldForHeaders(string name, hash<auto> headers);
 
 
      static *AbstractDataProviderType getCacheType(reference<hash<string, AbstractDataProviderType>> h, string key);
 
    AbstractDataField getFieldFromParameter(string path, string name, string type, *string format, *SchemaObject arrayItems, *string desc, bool required, *list<auto> allowed_values, auto default_value);
 
 
protected:
     addFieldsFromParametersIntern(HashDataType rv, hash<string, AbstractParameterObject> parameters, reference<bool> required);
public:
 
 
 
protected:
     string getHashImpl();
public:
 
 
 
protected:
     string getTargetUrlImpl();
public:
 
 
 
protected:
     hash<RestSchemaValidator::RestRequestClientInfo> processRequestImpl(string method, string path, auto body, *hash<auto> headers, *softlist<string> content_types);
public:
 
 
 
protected:
     hash<RestSchemaValidator::RestRequestServerInfo> parseRequestImpl(string method, string path, *data http_body, reference<hash> headers);
public:
 
 
 
protected:
     hash<HttpResponseInfo> processResponseImpl(string method, string path, int code, auto response_body, *hash<auto> headers, *softlist<string> content_types);
public:
 
 
 
protected:
     hash<RestSchemaValidator::RestResponseClientInfo> parseResponseImpl(string method, string path, int code, *data response_body, hash<auto> hdr);
public:
 
 
protected:
     fixPath(reference<string> path);
public:
 
 
 
protected:
     hash<string, list<string>> getPathOperationHashImpl();
public:
 
 
 
protected:
     string getBasePathImpl();
public:
 
 
 
protected:
     setBasePathImpl(string basePath);
public:
 
 
 
protected:
     hash<RestQoreExampleCodeInfo> getQoreExampleRequestImpl(string method, string path);
public:
 
 
 
protected:
     hash<RestSchemaValidator::RestExampleRequestInfo> getExampleRequestImpl(string method, string path, *softlist<string> content_types);
public:
 
 
 
protected:
     hash<RestQoreExampleCodeInfo> getQoreExampleResponseImpl(string method, string path, int code);
public:
 
 
 
protected:
     hash<RestExampleResponseInfo> getExampleResponseImpl(string method, string path, int code, *softlist<string> content_types);
public:
 
 
 
protected:
     hash<auto> getExternalReference(string refstr);
public:
 
 
 
protected:
     AbstractDataProvider getDataProviderImpl(HTTPClient rest);
public:
 
 
 
protected:
     setTimeZoneLocaleImpl(*TimeZone tz);
public:
 
 
 
protected:
     *TimeZone getTimeZoneLocaleImpl();
public:
 
 
 
private:
     hash<RestSchemaValidator::RestRequestClientInfo> processRequestIntern(string method, string path, auto body, *hash<auto> headers, *softlist<string> content_types, bool compact_serialization);
public:
 
 
 
private:
     hash<HttpResponseInfo> processResponseIntern(string method, string path, int code, auto response_body, *hash<auto> headers, *softlist<string> content_types, bool compact_serialization);
public:
 
 
 
private:
     bool checkRequestContentTypeHeader(reference<hash<RestRequestClientInfo>> req, auto body, *hash<auto> headers);
public:
 
 
 
private:
     bool checkResponseContentTypeHeader(reference<hash<HttpResponseInfo>> resp, auto body, *hash<auto> headers);
public:
 
 
 
private:
     bool checkResponseTextPlain(reference<hash<HttpResponseInfo>> resp, auto body, hash<string, bool> mime_types, *list<auto> content_types);
public:
 
 
private:
     SchemaObject processDefinition(string key, auto value);
public:
 
};
 
class InfoObject : public ObjectBase {
 
public:
        string title;
 
        *string desc;
 
        *string termsOfService;
 
        string version;
 
        *ContactObject contact;
 
        *LicenseObject license;
 
 
    constructor(hash<auto> oh) ;
 
};
 
class ContactObject : public ObjectBase {
 
public:
        *string name;
 
        *string url;
 
        *string email;
 
 
    constructor(hash<auto> oh) ;
 
};
 
class LicenseObject : public ObjectBase {
 
public:
        string name;
 
        *string url;
 
 
    constructor(hash<auto> oh) ;
 
};
 
 
class PathComponent : public Qore::Serializable {
 
public:
protected:
        string pfx;
 
        string name;
 
        *PathComponent wildcard;
 
        *PathItemObject pio;
 
        hash<string, PathComponent> paths;
 
public:
 
    constructor(hash<auto> oh, string pfx, SwaggerSchema swagger);
 
 
protected:
     constructor(string full_path, list<auto> l, int offset, hash<auto> oh);
public:
 
 
protected:
     add(string full_path, list<auto> l, int offset, hash<auto> oh, SwaggerSchema swagger);
public:
 
 
 
    PathItemObject match(list<auto> path);
 
 
 
    *PathItemObject tryMatch(list<auto> path);
 
 
 
    getPathOperationHash(reference<hash<string, list<string>>> h);
 
};
 
class PathsObject : public ObjectBase {
 
public:
protected:
        PathComponent paths;
 
public:
 
 
    constructor(hash<auto> oh, SwaggerSchema swagger) ;
 
 
 
    PathItemObject match(string path);
 
 
 
    *PathItemObject tryMatch(string path);
 
 
 
    hash<string, list<string>> getPathOperationHash();
 
};
 
 
class PathItemObject : public ParameterGroup {
 
public:
 
        *string ref;
 
        AbstractParameterObject body;
 
protected:
 
        hash<string, OperationObject> operations;
 
        const ObjType = "Path Item";
 
public:
 
 
    constructor(string path, hash<auto> oh, SwaggerSchema swagger) ;
 
 
    merge(string path, hash<auto> oh, SwaggerSchema swagger);
 
 
 
    OperationObject getOperation(string method, string path);
 
 
 
    softlist getMethods();
 
};
 
class OperationObject : public ParameterGroup {
 
public:
        string path;
 
        string method;
 
 
        list tags;
 
        *string summary;
 
        *string desc;
 
 
        bool deprec = False;
 
        *ExternalDocumentationObject externalDocs;
 
 
        *string operationId;
 
 
        hash<string, bool> consumes;
 
 
        hash<string, bool> produces;
 
        hash<string, AbstractParameterObject> formData;
 
        AbstractParameterObject body;
 
        ResponsesObject responses;
 
 
        list<string> schemes;
 
 
        list<hash<string, list<string>>> security;
 
 
    constructor(string path, string method, hash<auto> oh, SwaggerSchema swagger) ;
 
 
    *data getRequestBody(PathItemObject pio, auto body, reference<hash<auto>> headers, *bool freeform);
 
 
 
    validateRequest(bool serialize, PathItemObject pio, reference<hash<UriQueryInfo>> h, reference<auto> body, reference<hash> headers, *reference<hash<string, bool>> mime_types, *bool freeform);
 
 
 
    parseRequest(PathItemObject pio, reference<hash<UriQueryInfo>> h, reference<auto> body, reference<hash> headers);
 
 
    validateResponse(string method, string path, PathItemObject pio, int http_code, reference<auto> response_body, reference<hash<string, bool>> mime_types, bool deserialize = True);
 
 
 
    hash<RestQoreExampleCodeInfo> getQoreExampleRequest(string method, string path, PathItemObject pio, SwaggerSchema swagger);
 
 
 
    hash<RestSchemaValidator::RestExampleRequestInfo> getExampleRequest(string method, string path, PathItemObject pio, SwaggerSchema swagger, reference rbody);
 
 
 
    hash<RestQoreExampleCodeInfo> getQoreExampleResponse(string method, string path, int code);
 
 
 
    hash<RestExampleResponseInfo> getExampleResponse(string method, string path, int code, reference<auto> body);
 
 
protected:
     getQoreExampleParams(reference<hash<auto>> query, reference<hash<auto>> headers, hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params);
public:
 
 
protected:
     doDefaultParams(reference<hash<UriQueryInfo>> h, reference<hash> headers, reference<auto> body, hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params);
public:
 
 
protected:
     checkMissingParams(hash<UriQueryInfo> h, *hash<auto> headers, auto body, hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params);
public:
 
 
 
protected:
     *ResponseObject getResponse(int code);
public:
 
 
protected:
     error(string err, string fmt, ...);
public:
 
};
 
class ExternalDocumentationObject : public ObjectBase {
 
public:
        *string desc;
 
        string url;
 
 
    constructor(hash<auto> oh) ;
 
};
 
 
class AbstractParameterObject : public ObjectBase {
 
public:
 
        string name;
 
 
        string inLoc;
 
        *string desc;
 
 
        bool required = False;
 
protected:
        const OtherParameterMap = ...;
 
 
public:
 
 
    constructor(hash<auto> oh, *int opt_flags) ;
 
 
    abstract check(bool serialize, bool request, string path, string method, string name, reference value);
 
    auto getDefaultValue();
 
 
      static AbstractParameterObject newParameter(string name, hash<auto> oh, SwaggerSchema swagger);
};
 
class BodyParameter : public AbstractParameterObject {
 
public:
        SchemaObject schema;
 
 
    constructor(hash<auto> oh, SwaggerSchema swagger) ;
 
 
    check(bool serialize, bool request, string path, string method, string name, reference<auto> value);
 
 
    string getQoreExample(reference<hash<RestQoreExampleCodeInfo>> rv);
 
 
    // returns an example value for a REST API call
    auto getExampleValue(*hash<string, bool> emap, *string fname);
 
};
 
class TypedParameter : public AbstractParameterObject, public SchemaBase {
 
public:
 
        string type;
 
        *string format;
 
 
        bool allowEmptyValue = False;
 
        *SchemaObject items;
 
 
        *string collectionFormat;
 
 
        auto defaultVal;
 
    constructor(string name, hash<auto> oh, SwaggerSchema swagger) ;
 
 
    check(bool serialize, bool request, string path, string method, string name, reference<auto> value);
 
 
    auto getDefaultValue();
 
 
    auto getExampleValue(*hash<string, bool> emap, *string fname);
 
 
protected:
      static checkValueType(reference<auto> value, string type, *SchemaObject items, *string loc);
public:
 
 
protected:
    abstract  setType(SwaggerSchema swagger);
public:
};
 
class FormDataParameter : public TypedParameter {
 
public:
        const ParameterTypes = ...;
 
 
    constructor(string name, hash<auto> oh, SwaggerSchema swagger) ;
 
 
protected:
     setType(SwaggerSchema swagger);
public:
 
};
 
class OtherParameter : public TypedParameter {
 
public:
        const ParameterTypes = SchemaObject::ScalarTypes;
 
 
    constructor(string name, hash<auto> oh, SwaggerSchema swagger) ;
 
 
protected:
     setType(SwaggerSchema swagger);
public:
 
};
 
class ResponsesObject : public ObjectBase {
 
public:
        // The documentation of responses other than the ones declared for specific HTTP response codes.
        ResponseObject defaultResp;
 
        // A hash mapping HTTP status codes to @ref ResponseObject "ResponseObjects".
        hash<string, ResponseObject> responses;
 
 
    constructor(string path, string method, hash<auto> oh, SwaggerSchema swagger) ;
 
};
 
class ResponseObject : public ObjectBase {
 
public:
        string desc;
 
 
        *SchemaObject schema;
 
 
        hash<auto> headers;
 
 
        hash examples;
 
 
protected:
     constructor(string key, hash<auto> oh, SwaggerSchema swagger) ;
public:
 
 
 
      static ResponseObject newResponse(string key, hash<auto> oh, SwaggerSchema swagger);
};
 
class HeaderObject : public ObjectBase, public SchemaBase {
 
public:
        *string desc;
 
 
        string type;
 
        *string format;
 
        *SchemaObject items;
 
 
        *string collectionFormat;
 
 
        auto defaultVal;
 
 
    constructor(hash<auto> oh, SwaggerSchema swagger) ;
 
 
protected:
      static checkValueType(reference<auto> value, string type, *SchemaObject items, *string loc);
public:
 
};
 
class TagObject : public ObjectBase {
 
public:
        string name;
 
        *string desc;
 
        *ExternalDocumentationObject externalDocs;
 
 
    constructor(hash<auto> oh) ;
 
};
 
class SchemaObject : public ObjectBase, public SchemaBase {
 
public:
        string name;
 
 
        string type;
 
        *string format;
 
        *string title;
 
        *string desc;
 
        *SchemaObject items;
 
        auto defaultVal;
 
        *int maxProperties;
 
        *int minProperties;
 
 
        bool nullable = False;
 
 
        hash<string, SchemaObject> properties;
 
        hash<string, bool> nullable_properties;
 
 
        auto additionalProperties;
 
 
        hash<string, bool> required;
 
 
        *string discriminator;
 
 
        bool readOnly = False;
 
 
        list<SchemaObject> allOf();
 
 
        *XmlObject xml;
 
        *ExternalDocumentationObject externalDocs;
 
        auto example;
 
        *AbstractDataProviderType dataType;
 
        *AbstractDataProviderType orNothingDataType;
 
        const ScalarTypes = ...;
 
 
        const ReferenceTypes = ...;
 
 
protected:
        SwaggerSchema swagger;
 
        // maps fields: name -> {Y,N} -> field
        hash<string, hash<string, AbstractDataField>> fieldmap;
 
public:
 
 
protected:
     constructor(string name, hash<auto> oh, SwaggerSchema swagger, *string hash_str, *bool require_items) ;
public:
 
 
protected:
     constructor(SchemaObject o);
public:
 
 
protected:
     addProperties(hash<string, auto> props, *int opt_flags);
public:
 
 
    replaceType(AbstractDataProviderType t);
 
 
    AbstractDataProviderType getDataType(bool required = True, *HTTPClient rest);
 
 
protected:
     AbstractDataProviderType getDataTypeIntern(string path, bool required = True, *HTTPClient rest);
public:
 
 
    AbstractDataField getField(string name, *string desc, bool required = True, *HTTPClient rest, auto default_value);
 
 
    AbstractDataField getField(string path, string name, *string desc, bool required = True, *HTTPClient rest, auto default_value);
 
 
protected:
      static *AbstractDataField getCacheField(reference<hash<string, AbstractDataField>> h, string key);
public:
 
 
protected:
     getSchemaObjectFields(HashDataType type, string path, auto def_body);
public:
 
 
protected:
     AbstractDataField getFieldIntern(string path, string name, *string desc, bool required = True, *HTTPClient rest, auto default_value, *string rstr);
public:
 
 
    string getQoreExample(reference<hash<RestQoreExampleCodeInfo>> rv, string name, bool decl);
 
 
    // returns an example value for a REST API call
    auto getExampleValue(*hash<string, bool> emap, *string fname);
 
 
    check(bool serialize, bool request, string path, string method, string name, reference<auto> value);
 
 
protected:
     checkObjectProperty(string name, string prop);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, nothing v, reference<nothing> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, hash<auto> v, reference<hash<auto>> value, *bool no_check_others);
public:
 
 
protected:
      static checkValueType(reference<auto> value, string type, *SchemaObject items, *string loc);
public:
 
 
 
      static SchemaObject newSchemaObject(string name, hash<auto> oh, SwaggerSchema swagger, *bool require_items);
 
 
      static SchemaObject newSchemaObject(string name, auto error, SwaggerSchema swagger);
};
 
class ParameterItemsSchemaObject : public SchemaObject {
 
public:
 
        *string collectionFormat;
 
    constructor(SchemaObject o) ;
 
 
 
protected:
     constructor(string name, hash<auto> oh, SwaggerSchema swagger, *string inLoc) ;
public:
 
 
 
      static ParameterItemsSchemaObject newSchemaObject(string name, hash<auto> oh, SwaggerSchema swagger, *string inLoc);
 
 
      static ParameterItemsSchemaObject newSchemaObject(string name, auto error, SwaggerSchema swagger, *string inLoc);
};
 
 
class XmlObject : public ObjectBase {
 
public:
 
        *string name;
 
        *string ns;
 
        *string prefix;
 
 
        bool attribute = False;
 
 
        bool wrapped = False;
 
 
    constructor(hash<auto> oh) ;
 
};
 
 
class SecuritySchemeObject : public ObjectBase {
 
public:
        string type;
 
        *string desc;
 
 
        *string name;
 
 
        *string inLoc;
 
 
        *string flow;
 
 
        *string authorizationUrl;
 
 
        *string tokenUrl;
 
 
        *ScopesObject scopes;
 
 
    constructor(hash<auto> oh) ;
 
};
 
class ScopesObject : public ObjectBase {
 
public:
 
        hash<string, string> fields;
 
 
    constructor(hash<auto> oh) ;
 
};
};
 
// private namespace for internal definitions
namespace Priv {
    // a set of string values
    const SwaggerListToStringSet = -1;
    // a set of any type that can be converted to a string
    const SwaggerListToAnySet = -2;
    const SwaggerListToHashOfStrings = -3;
 
    const TypeMap = ...;
 
 
 
    required_field(string objType, hash<auto> oh, string name, int typeCode, reference<auto> target, *int opt_flags);
 
 
 
    required_field(string objType, hash<auto> oh, string name, hash<string, bool> typeCodes, reference<auto> target);
 
 
 
    bool optional_field(string objType, hash<auto> oh, string name, int typeCode, reference<auto> target, *int opt_flags);
 
 
 
    bool optional_field(string objType, hash<auto> oh, string name, hash<string, bool> typeCodes, reference<auto> target);
 
 
    *bool check_type_code(string objType, hash<auto> oh, string name, auto val, int typeCode, *int opt_flags);
 
 
    get_value(string objType, string name, int typeCode, auto val, reference<auto> target);
 
 
    string get_qore_type(string name, string type, *string format, *SchemaObject items);
 
};