Swagger.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  Swagger.qm Copyright (C) 2017 - 2023 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_ALL = ...;
 
 
const ValidIntFormats = ("int32", "int64");
const ValidNumberFormats = ("double", "float");
const ValidStringFormats = ("binary", "byte", "date", "date-time", "password");
 
const CollectionFormats = ...;
 
 
const ParameterCollectionFormats = ...;
 
 
const ValidIntFormatsHash = map {$1: True}, ValidIntFormats;
const ValidNumberFormatsHash = map {$1: True}, ValidNumberFormats;
const ValidStringFormatsHash = map {$1: True}, ValidStringFormats;
 
const YamlSerialization = {
    "serialize": \make_yaml(),
    "serialize_verbose": string sub (auto val) {return make_yaml(val, BlockStyle);},
    "deserialize": \parse_yaml(),
    "module": "yaml",
};
 
const MimeDataTypes = {
%ifndef NoJson
    MimeTypeJson: (
        "serialize": \make_json(),
        "serialize_verbose": string sub (auto val) {return make_json(val, JGF_ADD_FORMATTING);},
        "deserialize": \parse_json(),
        "module": "json",
    ),
%endif
%ifndef NoYaml
    // issue #3699: more YAML MIME types must be supported
    MimeTypeYaml: YamlSerialization,
    MimeTypeYamlRpc: YamlSerialization,
    "text/yaml": YamlSerialization,
    "application/yaml": YamlSerialization,
%endif
%ifndef NoXml
    MimeTypeXmlApp: (
        "serialize": \make_xml(),
        "serialize_verbose": string sub (auto val) {return make_xml(val, XGF_ADD_FORMATTING);},
        "deserialize": \parse_xml(),
        "module": "xml",
    ),
%endif
    # Content-Type: application/x-www-form-urlencoded
    MimeTypeFormUrlEncoded: (
        "serialize": \mime_get_form_urlencoded_string(),
        "serialize_verbose": \mime_get_form_urlencoded_string(),
        "deserialize": \mime_parse_form_urlencoded_string(),
    ),
    # Content-Type: multipart/form-data (handled manually)
    MimeTypeMultipartFormData: {},
};
 
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:
 
        hash<auto> vendorExtensions;
 
    constructor();
 
 
 
    constructor(hash<auto> oh);
 
 
    constructor(ObjectBase other);
 
 
 
     initialize(hash<auto> oh);
};
 
class SchemaBase {
 
public:
        *float maximum;
 
        *float 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:
     auto getExampleValue(string type, *string format);
public:
 
 
    private check(bool serialize, bool request, string type, *string format, *SchemaObject items, string path,
            string method, string name, reference<auto> value) {
        // accept a single value for an array (= one-element list)
        if (type == 'array');
 else {
            checkIntern(serialize, request, type, format, path, method, name, value, \value);
        }
    }
 
protected:
     checkStringIntern(string path, string method, string name, string value);
public:
 
 
    private checkIntern(bool serialize, bool request, string type, *string format, string path, string method,
            string name, list<auto> v, reference<list> value) {
        if (type != "list" && type != "any")
            throw "SCHEMA-VALIDATION-ERROR", sprintf("Parameter %y for path %y and method %y is an array (%y), but "
                "the expected type is %y", name, path, method, v, type);
    }
 
    private checkIntern(bool serialize, bool request, string type, *string format, string path, string method,
            string name, hash<auto> v, reference<hash> value) {
        if (type != "file" && type != "any")
            throw "SCHEMA-VALIDATION-ERROR", sprintf("Parameter %y for path %y and method %y is an object (%y), but "
                "the expected type is %y", name, path, method, v, type);
    }
 
    private checkIntern(bool serialize, bool request, string type, *string format, string path, string method,
            string name, int v, reference<auto> value) {
        // NOTE: "number" also accepts "int"
        if (type == 'number');
 
        if (type != "integer" && type != "any")
            throwInvalidType(name, "integer", type, v);
        if (exists maximum);
 
 
        if (exists minimum);
 
 
        if (enum && !enum{value})
            throw "SCHEMA-VALIDATION-ERROR",
                sprintf("Parameter %y for path %y and method %y does not fit the enumerated values (enum: %y, actual: %d)",
                    name, path, method, keys enum, value);
    }
 
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:
 
 
    private checkIntern(bool serialize, bool request, string type, *string format, string path, string method,
            string name, binary v, reference value) {
        if (type != "string" && type != "any")
            throwInvalidType(name, "string", type, v);
 
        if (serialize);
 
    }
 
    private checkIntern(bool serialize, bool request, string type, *string format, string path, string method,
            string name, string v, reference<auto> value) {
        if (type != 'string' && type != 'any');
 
 
        if (serialize);
                        # https://xml2rfc.tools.ietf.org//rfc/html/rfc3339.html#anchor14        if (value.typeCode() == NT_STRING);
 
    }
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, date v, reference 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:
 
 
    private checkArrayParam(bool serialize, bool request, SchemaObject items, string path, string method, string name,
            reference<softlist<auto>> value) {
        if (exists maxItems && value.size() > maxItems)
            throw "SCHEMA-VALIDATION-ERROR",
                sprintf("Parameter %y for path %y and method %y has too many items (maxItems: %d, actual: %d)",
                    name, path, method, maxItems, value.size());
        if (exists minItems && value.size() < minItems)
            throw "SCHEMA-VALIDATION-ERROR",
                sprintf("Parameter %y for path %y and method %y has too few items (minItems: %d, actual: %d)",
                    name, path, method, minItems, value.size());
 
        // check array element types
        if (!uniqueItems || items.type != 'array');
 else {
            // perform slow array uniqueness check
            list<auto> uniqueItems = ();
            foreach auto val in (\value) {
                items.check(serialize, request, path, method, name, \val);
                if (uniqueItems.contains(val))
                    throw "SCHEMA-VALIDATION-ERROR",
                        sprintf("%s %s: Array parameter %y does not have unique items",
                            method, path, name);
                uniqueItems += val;
            }
        }
    }
 
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 SwaggerSchema : public ObjectBase,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, AbstractParameterObject> parameters();
 
 
        hash<string, ResponseObject> responses;
 
 
        hash<string, SecuritySchemeObject> securityDefinitions;
 
 
        hash<string, softlist<string>> security;
 
 
        list<TagObject> tags;
 
        *ExternalDocumentationObject externalDocs;
 
        const SwaggerOptions = ...;
 
 
protected:
        bool compact_serialization;
 
        *string def_path;
 
 
        *code try_import;
 
        string hash_str;
 
        *int opt_flags;
 
        hash<string, hash<string, SchemaObject>> so_map;
 
public:
 
private:
        *hash<auto> source_definition_hash;
 
public:
 
 
    constructor(string schema_source, hash<auto> oh, *hash<auto> opts) ;
 
 
 
    constructor(Logger logger, string schema_source, hash<auto> oh, *hash<auto> opts) : ObjectBase(oh),
            AbstractRestSchemaValidator(logger);
 
 
protected:
     constructorIntern(string schema_source, hash<auto> oh, *hash<auto> opts);
public:
 
 
    *int getParseFlags();
 
 
    *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);
 
 
 
    AbstractParameterObject resolveParameter(string name, string refstr, hash<auto> oh);
 
 
 
    ResponseObject resolveResponse(string name, string refstr, hash<auto> oh);
 
 
 
protected:
     string getHashImpl();
public:
 
 
 
protected:
     string getTargetUrlImpl();
public:
 
 
 
    private hash<RestSchemaValidator::RestRequestClientInfo> processRequestImpl(string method, string path, auto body,
            *hash<auto> headers, *softlist<string> content_types) {
        return processRequestIntern(method, path, body, headers, content_types, compact_serialization);
    }
 
 
    private hash<RestSchemaValidator::RestRequestServerInfo> parseRequestImpl(string method, string path,
            *data http_body, reference<hash> headers) {
        auto body;
        // deserialize body according to Content-Type
        if (exists http_body);
 
 
        // path must be absolute for matching to work correctly
        if (path ==1)
            path = "/" + path;
 
        // remove basePath if present; note that "basePath" must always have a leading / if set
        fixPath(\path);
 
        hash<UriQueryInfo> h = parse_uri_query(path);
        method = method.lwr();
        PathItemObject pio = paths.match(h.method);
        OperationObject op = pio.getOperation(method, h.method);
 
        op.parseRequest(pio, \h, \body, \headers);
        return <RestRequestServerInfo>{
            "path": h.method,
            "query": h.params,
            "path_args": h.path_params,
            "body": body,
        };
    }
 
 
    private hash<HttpResponseInfo> processResponseImpl(string method, string path, int code, auto response_body,
            *hash<auto> headers, *softlist<string> content_types) {
        return processResponseIntern(method, path, code, response_body, headers, content_types,
            compact_serialization);
    }
 
 
    private hash<RestSchemaValidator::RestResponseClientInfo> parseResponseImpl(string method, string path, int code,
            *data response_body, hash<auto> hdr) {
        // remove basePath if present
        fixPath(\path);
 
        method = method.lwr();
        PathItemObject pio = paths.match(path);
        OperationObject op = pio.getOperation(method, path);
 
        hash<RestResponseClientInfo> rv((
            "code": code,
            "hdr": hdr,
        ));
 
        *string content = hdr."content-type" ?? hdr."Content-Type";
 
        // deserialize body according to Content-Type
        if (exists response_body && content);
 
 
        hash<string, bool> mime_types;
        op.validateResponse(method, path, pio, code, \rv.body, \mime_types, False);
 
        if (content && !mime_types{content})
            throw "DESERIALIZATION-ERROR", sprintf("%s %s: content type %y is not accepted by this operation; "
                "accepted content types: %y", method.upr(), path, content, keys mime_types);
 
        return rv;
    }
 
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:
 
 
 
    private hash<RestSchemaValidator::RestExampleRequestInfo> getExampleRequestImpl(string method, string path,
            *softlist<string> content_types) {
        // remove basePath if present
        fixPath(\path);
 
        method = method.lwr();
        PathItemObject pio = paths.match(path);
        OperationObject op = pio.getOperation(method, path);
 
        auto body;
        hash<RestExampleRequestInfo> rv = op.getExampleRequest(method, path, pio, self, \body);
        if (exists body);
 
 
        return rv;
    }
 
 
protected:
     hash<RestQoreExampleCodeInfo> getQoreExampleResponseImpl(string method, string path, int code);
public:
 
 
 
    private hash<RestExampleResponseInfo> getExampleResponseImpl(string method, string path, int code,
            *softlist<string> content_types) {
        // remove basePath if present
        fixPath(\path);
 
        method = method.lwr();
        PathItemObject pio = paths.match(path);
        OperationObject op = pio.getOperation(method, path);
 
        auto body;
        hash<RestExampleResponseInfo> rv = op.getExampleResponse(method, path, code, \body);
        if (exists body);
 
 
        return rv;
    }
 
 
protected:
     hash<auto> getExternalReference(string refstr);
public:
 
 
 
protected:
     AbstractDataProvider getDataProviderImpl(HTTPClient rest);
public:
 
 
 
protected:
     setTimeZoneLocaleImpl(*TimeZone tz);
public:
 
 
 
protected:
     *TimeZone getTimeZoneLocaleImpl();
public:
 
 
 
    private:internal hash<RestSchemaValidator::RestRequestClientInfo> processRequestIntern(string method, string path,
            auto body, *hash<auto> headers, *softlist<string> content_types, bool compact_serialization) {
        // remove basePath if present
        fixPath(\path);
 
        hash<UriQueryInfo> h = parse_uri_query(path);
 
        // find path item object and operation
        method = method.lwr();
        PathItemObject pio = paths.match(h.method);
        OperationObject op = pio.getOperation(method, h.method);
 
        // perform validation
        hash<string, bool> mime_types;
        op.validateRequest(True, pio, \h, \body, \headers, \mime_types);
 
        hash<RestRequestClientInfo> rv((
            "uri_path": h.method,
        ));
 
        if (op.produces);
 
 
        // add the basePath to the request
        if (exists basePath);
 
 
        // rebuild URI query after processing
        if (h.params);
 
 
        if (!body);
 
 
        if (!exists content_types);
 
 
        foreach string content in (content_types);
 
 
        // check if the \c Content-Type header is already set
        if (checkRequestContentTypeHeader(\rv, body, headers));
 
 
        if (content_types == MimeContentTypes);
 else {
            throw "SERIALIZATION-ERROR", sprintf("%s %s: message body cannot be serialized; requested MIME type(s): "
                "%y; available MIME types: %y; available serialization modules: %y", method.upr(), path,
                content_types, mime_types, SerializationModules);
        }
    }
 
 
    private:internal hash<HttpResponseInfo> processResponseIntern(string method, string path, int code,
            auto response_body, *hash<auto> headers, *softlist<string> content_types, bool compact_serialization) {
        // find path item object and operation
        method = method.lwr();
        PathItemObject pio = paths.match(path);
        OperationObject op = pio.getOperation(method, path);
 
        // perform validation
        hash<string, bool> mime_types;
        op.validateResponse(method, path, pio, code, \response_body, \mime_types);
 
        hash<HttpResponseInfo> rv((
            "code": code,
            "hdr": headers,
        ));
 
        if (exists response_body);
 
 
        return rv;
    }
 
 
    private:internal bool checkRequestContentTypeHeader(reference<hash<RestRequestClientInfo>> req, auto body,
            *hash<auto> headers) {
        // quickly return if body is not in data format
        if (body.typeCode() != NT_BINARY && body.typeCode() != NT_STRING)
            return False;
 
        // try to find \c Content-Type header
        *list<string> ct = map $1, keys headers, $1 ==1i;
 
        // if found and it's not one of the default ones, use it
        if (ct && ct.size() == 1 && !MimeDataTypes{headers{ct[0]}});
 
        return False;
    }
 
 
    private:internal bool checkResponseContentTypeHeader(reference<hash<HttpResponseInfo>> resp, auto body,
            *hash<auto> headers) {
        // quickly return if body is not in data format
        if (body.typeCode() != NT_BINARY && body.typeCode() != NT_STRING)
            return False;
 
        // try to find \c Content-Type header
        *list<string> ct = map $1, keys headers, $1 ==1i;
 
        // if found, use it and don't serialize the body
        if (ct && ct.size() == 1);
 
        return False;
    }
 
 
    private:internal bool checkResponseTextPlain(reference<hash<HttpResponseInfo>> resp, auto body,
            hash<string, bool> mime_types, *list<auto> content_types) {
        // quickly return if body is not string
        if (body.typeCode() != NT_STRING)
            return False;
 
        // return if text/plain is not allowed for this operation
        if (!mime_types."text/plain")
            return False;
 
        if (content_types);
 
 
        resp.body = body;
        resp.hdr."Content-Type" = "text/plain";
        return True;
    }
 
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:
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 ObjectBase {
 
public:
 
        *string ref;
 
 
        hash<string, AbstractParameterObject> parameters();
 
        AbstractParameterObject body;
 
protected:
 
        hash<string, OperationObject> operations;
 
public:
 
 
    constructor(string path, hash<auto> oh, SwaggerSchema swagger) ;
 
 
 
    OperationObject getOperation(string method, string path);
 
 
 
    softlist getMethods();
 
};
 
class OperationObject : public ObjectBase {
 
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> parameters();
 
        AbstractParameterObject body;
 
        hash<string, AbstractParameterObject> formData;
 
        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);
 
 
 
    validateRequest(bool serialize, PathItemObject pio, reference<hash<UriQueryInfo>> h, reference<auto> body,
            reference<hash> headers, *reference<hash<string, bool>> mime_types) {
        // check query parameters
        foreach string key in (keys h.params);
 
 
        // check header parameters
        foreach string key in (keys headers);
 
 
        // check body parameters
        {
            *AbstractParameterObject body_po = self.body ?? pio.body;
            if (body_po)  {
                body_po.check(serialize, True, path, method, "body", \body);
            } else if (formData) {
                foreach hash<auto> i in (formData.pairIterator()) {
                    i.value.check(serialize, True, path, method, "formData." + i.key, \body{i.key});
                }
            } else if (body) {
                error("SCHEMA-VALIDATION-ERROR", "No message body is accepted; body keys passed: %y", keys body);
            }
        }
 
        // check path parameters
        foreach string param in (path =~ x/{([^}]+)}/g);
 
 
        // check for missing required parameters
        checkMissingParams(h, headers, body, parameters);
        checkMissingParams(h, headers, body, pio.parameters, parameters);
 
        if (consumes);
 
    };
 
 
    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) {
        *ResponseObject res = getResponse(http_code);
        if (res.schema);
 else if (exists res && exists response_body);
 
 
        if (produces);
 
    }
 
 
    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<RestExampleRequestInfo> rv();
 
        hash<auto> query;
 
        getQoreExampleParams(\query, \rv.hdr, parameters);
        getQoreExampleParams(\query, \rv.hdr, pio.parameters, parameters);
 
        rv.request_uri = sprintf("%s %s HTTP/1.1", method.upr(),
            make_uri_query(cast<hash<UriQueryInfo>>({"method": path, "params": query})));
 
        *BodyParameter body_po = body ?? pio.body;
        if (body_po)
            rbody = body_po.getExampleValue();
 
        return rv;
    }
 
 
    hash<RestQoreExampleCodeInfo> getQoreExampleResponse(string method, string path, int code);
 
 
 
    hash<RestExampleResponseInfo> getExampleResponse(string method, string path, int code, reference<auto> body);
 
 
    private getQoreExampleParams(reference<hash<auto>> query, reference<hash<auto>> headers,
            hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params) {
        foreach hash<auto> ph in (parameters.pairIterator());
 
    }
 
    private doDefaultParams(reference<hash<UriQueryInfo>> h, reference<hash> headers, reference<auto> body,
            hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params) {
        foreach hash<auto> ph in (parameters.pairIterator());
 
    }
 
    private checkMissingParams(hash<UriQueryInfo> h, *hash<auto> headers, auto body,
            hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params) {
        foreach hash<auto> ph in (parameters.pairIterator());
 
    }
 
 
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 value);
 
 
    string getQoreExample(reference<hash<RestQoreExampleCodeInfo>> rv);
 
 
    // returns an example value for a REST API call
    auto getExampleValue();
 
};
 
class OtherParameter : public AbstractParameterObject,public  SchemaBase {
 
public:
 
        string type;
 
        *string format;
 
 
        bool allowEmptyValue = False;
 
        *ParameterItemsSchemaObject items;
 
 
        *string collectionFormat;
 
 
        auto defaultVal;
 
        const ParameterTypes = ...;
 
 
 
    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();
 
 
protected:
      static checkValueType(reference<auto> value, string type, *SchemaObject items, *string loc);
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;
 
 
        auto additionalProperties;
 
 
        hash<string, bool> required;
 
 
        *string discriminator;
 
 
        bool readOnly = False;
 
 
        list<SchemaObject> allOf();
 
 
        *XmlObject xml;
 
        *ExternalDocumentationObject externalDocs;
 
        auto example;
 
        const ScalarTypes = ...;
 
 
        const ReferenceTypes = ...;
 
 
 
protected:
     constructor(string name, hash<auto> oh, SwaggerSchema swagger, *string hash_str, *bool require_items)
public:
 
 
    string getQoreExample(reference<hash<RestQoreExampleCodeInfo>> rv, string name, bool decl);
 
 
    // returns an example value for a REST API call
    auto getExampleValue();
 
 
    check(bool serialize, bool request, string path, string method, string name, reference<auto> value);
 
 
protected:
     checkObjectProperty(string name, string prop);
public:
 
 
    private checkIntern(bool serialize, bool request, string type, *string format, string path, string method,
            string name, hash<auto> v, reference<hash<auto>> value) {
        if (type != "object" && type != "any")
            throwInvalidType(name, "object", type, v);
 
        // check "allOf" schemas, if any
        map $1.checkIntern(serialize, request, type, NOTHING, path, method, name, v, \value), allOf;
 
        /*
            If additionalProperties is set to true, any number of additionalProperties may be present of any data
            type.
            If additionalProperties is a schema, additional properties (beyond what are defined in ‘properties’) are
            allowed and must match the schema
        */
        // check properties in this schema definition
        if (!additionalProperties && type != 'any');
 
        // check for missing required properties
        foreach string prop in (keys required);
 
        //printf("SchemaObject::checkIntern() %y type: %y val: %y self: %N\n", name, type, value, self);
    }
 
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;
 
 
protected:
     constructor(string name, hash<auto> oh, SwaggerSchema swagger) ;
public:
 
 
 
      static ParameterItemsSchemaObject newSchemaObject(string name, hash<auto> oh, SwaggerSchema swagger);
 
 
      static ParameterItemsSchemaObject newSchemaObject(string name, auto error, SwaggerSchema swagger);
};
 
 
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) {
        if (!oh.hasKey(name))
            return False;
        auto val = oh{name};
        if (check_type_code(objType, oh, name, val, typeCode, opt_flags));
 
        get_value(objType, name, typeCode, val, \target);
        return True;
    }
 
 
    bool optional_field(string objType, hash<auto> oh, string name, hash<string, bool> typeCodes,
            reference<auto> target) {
        if (!oh.hasKey(name))
            return False;
        auto val = oh{name};
        if (!typeCodes{val.typeCode()})
            throw "INVALID-FIELD-TYPE", sprintf("%s Object%s: %y field has invalid type %y", objType,
                oh.name ? sprintf(" %y", oh.name) : "", name, val.type());
        get_value(objType, name, val.typeCode(), val, \target);
        return True;
    }
 
    *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);
 
}