Billhighway Cloud API

OpenApiSpecRequest

The following routes are available for this service:
GET	/oas

import 'package:servicestack/servicestack.dart';

// @DataContract
class OpenApiContact implements IConvertible
{
    // @DataMember(Name="name")
    String? Name;

    // @DataMember(Name="url")
    String? Url;

    // @DataMember(Name="email")
    String? Email;

    OpenApiContact({this.Name,this.Url,this.Email});
    OpenApiContact.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Url = json['Url'];
        Email = json['Email'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Url': Url,
        'Email': Email
    };

    getTypeName() => "OpenApiContact";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiLicense implements IConvertible
{
    // @DataMember(Name="name")
    String? Name;

    // @DataMember(Name="url")
    String? Url;

    OpenApiLicense({this.Name,this.Url});
    OpenApiLicense.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Url = json['Url'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Url': Url
    };

    getTypeName() => "OpenApiLicense";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiInfo implements IConvertible
{
    // @DataMember(Name="title")
    String? Title;

    // @DataMember(Name="description")
    String? Description;

    // @DataMember(Name="termsOfServiceUrl")
    String? TermsOfServiceUrl;

    // @DataMember(Name="contact")
    OpenApiContact? Contact;

    // @DataMember(Name="license")
    OpenApiLicense? License;

    // @DataMember(Name="version")
    String? Version;

    OpenApiInfo({this.Title,this.Description,this.TermsOfServiceUrl,this.Contact,this.License,this.Version});
    OpenApiInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Title = json['Title'];
        Description = json['Description'];
        TermsOfServiceUrl = json['TermsOfServiceUrl'];
        Contact = JsonConverters.fromJson(json['Contact'],'OpenApiContact',context!);
        License = JsonConverters.fromJson(json['License'],'OpenApiLicense',context!);
        Version = json['Version'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Title': Title,
        'Description': Description,
        'TermsOfServiceUrl': TermsOfServiceUrl,
        'Contact': JsonConverters.toJson(Contact,'OpenApiContact',context!),
        'License': JsonConverters.toJson(License,'OpenApiLicense',context!),
        'Version': Version
    };

    getTypeName() => "OpenApiInfo";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiExternalDocumentation implements IConvertible
{
    // @DataMember(Name="description")
    String? Description;

    // @DataMember(Name="url")
    String? Url;

    OpenApiExternalDocumentation({this.Description,this.Url});
    OpenApiExternalDocumentation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Description = json['Description'];
        Url = json['Url'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Description': Description,
        'Url': Url
    };

    getTypeName() => "OpenApiExternalDocumentation";
    TypeContext? context = _ctx;
}

// @DataContract
abstract class OpenApiDataTypeSchema
{
    // @DataMember(Name="$ref")
    String? Ref;

    // @DataMember(Name="description")
    String? Description;

    // @DataMember(Name="type")
    String? Type;

    // @DataMember(Name="format")
    String? Format;

    // @DataMember(Name="items")
    Map<String,dynamic?>? Items;

    // @DataMember(Name="collectionFormat")
    String? CollectionFormat;

    // @DataMember(Name="default")
    String? Default;

    // @DataMember(Name="maximum")
    double? Maximum;

    // @DataMember(Name="exclusiveMaximum")
    bool? ExclusiveMaximum;

    // @DataMember(Name="minimum")
    double? Minimum;

    // @DataMember(Name="exclusiveMinimum")
    bool? ExclusiveMinimum;

    // @DataMember(Name="maxLength")
    int? MaxLength;

    // @DataMember(Name="minLength")
    int? MinLength;

    // @DataMember(Name="pattern")
    String? Pattern;

    // @DataMember(Name="maxItems")
    int? MaxItems;

    // @DataMember(Name="minItems")
    int? MinItems;

    // @DataMember(Name="uniqueItems")
    bool? UniqueItems;

    // @DataMember(Name="maxProperties")
    String? MaxProperties;

    // @DataMember(Name="minProperties")
    String? MinProperties;

    // @DataMember(Name="required")
    bool? Required;

    // @DataMember(Name="enum")
    List<String>? Enum;

    // @DataMember(Name="multipleOf")
    double? MultipleOf;

    // @DataMember(Name="x-nullable")
    bool? Nullable;

    OpenApiDataTypeSchema({this.Ref,this.Description,this.Type,this.Format,this.Items,this.CollectionFormat,this.Default,this.Maximum,this.ExclusiveMaximum,this.Minimum,this.ExclusiveMinimum,this.MaxLength,this.MinLength,this.Pattern,this.MaxItems,this.MinItems,this.UniqueItems,this.MaxProperties,this.MinProperties,this.Required,this.Enum,this.MultipleOf,this.Nullable});
    OpenApiDataTypeSchema.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Ref = json['Ref'];
        Description = json['Description'];
        Type = json['Type'];
        Format = json['Format'];
        Items = JsonConverters.fromJson(json['Items'],'Map<String,dynamic?>',context!);
        CollectionFormat = json['CollectionFormat'];
        Default = json['Default'];
        Maximum = JsonConverters.toDouble(json['Maximum']);
        ExclusiveMaximum = json['ExclusiveMaximum'];
        Minimum = JsonConverters.toDouble(json['Minimum']);
        ExclusiveMinimum = json['ExclusiveMinimum'];
        MaxLength = json['MaxLength'];
        MinLength = json['MinLength'];
        Pattern = json['Pattern'];
        MaxItems = json['MaxItems'];
        MinItems = json['MinItems'];
        UniqueItems = json['UniqueItems'];
        MaxProperties = json['MaxProperties'];
        MinProperties = json['MinProperties'];
        Required = json['Required'];
        Enum = JsonConverters.fromJson(json['Enum'],'List<String>',context!);
        MultipleOf = JsonConverters.toDouble(json['MultipleOf']);
        Nullable = json['Nullable'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Ref': Ref,
        'Description': Description,
        'Type': Type,
        'Format': Format,
        'Items': JsonConverters.toJson(Items,'Map<String,dynamic?>',context!),
        'CollectionFormat': CollectionFormat,
        'Default': Default,
        'Maximum': Maximum,
        'ExclusiveMaximum': ExclusiveMaximum,
        'Minimum': Minimum,
        'ExclusiveMinimum': ExclusiveMinimum,
        'MaxLength': MaxLength,
        'MinLength': MinLength,
        'Pattern': Pattern,
        'MaxItems': MaxItems,
        'MinItems': MinItems,
        'UniqueItems': UniqueItems,
        'MaxProperties': MaxProperties,
        'MinProperties': MinProperties,
        'Required': Required,
        'Enum': JsonConverters.toJson(Enum,'List<String>',context!),
        'MultipleOf': MultipleOf,
        'Nullable': Nullable
    };

    getTypeName() => "OpenApiDataTypeSchema";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiXmlObject implements IConvertible
{
    // @DataMember(Name="name")
    String? Name;

    // @DataMember(Name="namespace")
    String? Namespace;

    // @DataMember(Name="prefix")
    String? Prefix;

    // @DataMember(Name="attribute")
    bool? Attribute;

    // @DataMember(Name="wrapped")
    bool? Wrapped;

    OpenApiXmlObject({this.Name,this.Namespace,this.Prefix,this.Attribute,this.Wrapped});
    OpenApiXmlObject.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Namespace = json['Namespace'];
        Prefix = json['Prefix'];
        Attribute = json['Attribute'];
        Wrapped = json['Wrapped'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Namespace': Namespace,
        'Prefix': Prefix,
        'Attribute': Attribute,
        'Wrapped': Wrapped
    };

    getTypeName() => "OpenApiXmlObject";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiProperty extends OpenApiDataTypeSchema implements IConvertible
{
    OpenApiProperty();
    OpenApiProperty.fromJson(Map<String, dynamic> json) : super.fromJson(json);
    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson();
    getTypeName() => "OpenApiProperty";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiSchema extends OpenApiDataTypeSchema implements IConvertible
{
    // @DataMember(Name="title")
    String? Title;

    // @DataMember(Name="discriminator")
    String? Discriminator;

    // @DataMember(Name="readOnly")
    bool? ReadOnly;

    // @DataMember(Name="xml")
    OpenApiXmlObject? Xml;

    // @DataMember(Name="externalDocs")
    OpenApiExternalDocumentation? ExternalDocs;

    // @DataMember(Name="example")
    String? Example;

    // @DataMember(Name="required")
    List<String>? Required;

    // @DataMember(Name="allOf")
    OpenApiSchema? AllOf;

    // @DataMember(Name="properties")
    OrderedDictionary<String,OpenApiProperty>? Properties;

    // @DataMember(Name="additionalProperties")
    OpenApiProperty? AdditionalProperties;

    OpenApiSchema({this.Title,this.Discriminator,this.ReadOnly,this.Xml,this.ExternalDocs,this.Example,this.Required,this.AllOf,this.Properties,this.AdditionalProperties});
    OpenApiSchema.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Title = json['Title'];
        Discriminator = json['Discriminator'];
        ReadOnly = json['ReadOnly'];
        Xml = JsonConverters.fromJson(json['Xml'],'OpenApiXmlObject',context!);
        ExternalDocs = JsonConverters.fromJson(json['ExternalDocs'],'OpenApiExternalDocumentation',context!);
        Example = json['Example'];
        Required = JsonConverters.fromJson(json['Required'],'List<String>',context!);
        AllOf = JsonConverters.fromJson(json['AllOf'],'OpenApiSchema',context!);
        Properties = JsonConverters.fromJson(json['Properties'],'OrderedDictionary<String,OpenApiProperty>',context!);
        AdditionalProperties = JsonConverters.fromJson(json['AdditionalProperties'],'OpenApiProperty',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Title': Title,
        'Discriminator': Discriminator,
        'ReadOnly': ReadOnly,
        'Xml': JsonConverters.toJson(Xml,'OpenApiXmlObject',context!),
        'ExternalDocs': JsonConverters.toJson(ExternalDocs,'OpenApiExternalDocumentation',context!),
        'Example': Example,
        'Required': JsonConverters.toJson(Required,'List<String>',context!),
        'AllOf': JsonConverters.toJson(AllOf,'OpenApiSchema',context!),
        'Properties': JsonConverters.toJson(Properties,'OrderedDictionary<String,OpenApiProperty>',context!),
        'AdditionalProperties': JsonConverters.toJson(AdditionalProperties,'OpenApiProperty',context!)
    });

    getTypeName() => "OpenApiSchema";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiParameter extends OpenApiDataTypeSchema implements IConvertible
{
    // @DataMember(Name="name")
    String? Name;

    // @DataMember(Name="in")
    String? In;

    // @DataMember(Name="schema")
    OpenApiSchema? Schema;

    // @DataMember(Name="allowEmptyValue")
    bool? AllowEmptyValue;

    OpenApiParameter({this.Name,this.In,this.Schema,this.AllowEmptyValue});
    OpenApiParameter.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Name = json['Name'];
        In = json['In'];
        Schema = JsonConverters.fromJson(json['Schema'],'OpenApiSchema',context!);
        AllowEmptyValue = json['AllowEmptyValue'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Name': Name,
        'In': In,
        'Schema': JsonConverters.toJson(Schema,'OpenApiSchema',context!),
        'AllowEmptyValue': AllowEmptyValue
    });

    getTypeName() => "OpenApiParameter";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiResponse implements IConvertible
{
    // @DataMember(Name="description")
    String? Description;

    // @DataMember(Name="schema")
    OpenApiSchema? Schema;

    // @DataMember(Name="headers")
    Map<String,OpenApiProperty?>? Headers;

    // @DataMember(Name="examples")
    Map<String,String?>? Examples;

    OpenApiResponse({this.Description,this.Schema,this.Headers,this.Examples});
    OpenApiResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Description = json['Description'];
        Schema = JsonConverters.fromJson(json['Schema'],'OpenApiSchema',context!);
        Headers = JsonConverters.fromJson(json['Headers'],'Map<String,OpenApiProperty?>',context!);
        Examples = JsonConverters.toStringMap(json['Examples']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Description': Description,
        'Schema': JsonConverters.toJson(Schema,'OpenApiSchema',context!),
        'Headers': JsonConverters.toJson(Headers,'Map<String,OpenApiProperty?>',context!),
        'Examples': Examples
    };

    getTypeName() => "OpenApiResponse";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiOperation implements IConvertible
{
    // @DataMember(Name="tags")
    List<String>? Tags;

    // @DataMember(Name="summary")
    String? Summary;

    // @DataMember(Name="description")
    String? Description;

    // @DataMember(Name="externalDocs")
    OpenApiExternalDocumentation? ExternalDocs;

    // @DataMember(Name="operationId")
    String? OperationId;

    // @DataMember(Name="consumes")
    List<String>? Consumes;

    // @DataMember(Name="produces")
    List<String>? Produces;

    // @DataMember(Name="parameters")
    List<OpenApiParameter>? Parameters;

    // @DataMember(Name="responses")
    OrderedDictionary<String,OpenApiResponse>? Responses;

    // @DataMember(Name="schemes")
    List<String>? Schemes;

    // @DataMember(Name="deprecated")
    bool? Deprecated;

    // @DataMember(Name="security")
    List<Map<String,List<String>>>? Security;

    OpenApiOperation({this.Tags,this.Summary,this.Description,this.ExternalDocs,this.OperationId,this.Consumes,this.Produces,this.Parameters,this.Responses,this.Schemes,this.Deprecated,this.Security});
    OpenApiOperation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Tags = JsonConverters.fromJson(json['Tags'],'List<String>',context!);
        Summary = json['Summary'];
        Description = json['Description'];
        ExternalDocs = JsonConverters.fromJson(json['ExternalDocs'],'OpenApiExternalDocumentation',context!);
        OperationId = json['OperationId'];
        Consumes = JsonConverters.fromJson(json['Consumes'],'List<String>',context!);
        Produces = JsonConverters.fromJson(json['Produces'],'List<String>',context!);
        Parameters = JsonConverters.fromJson(json['Parameters'],'List<OpenApiParameter>',context!);
        Responses = JsonConverters.fromJson(json['Responses'],'OrderedDictionary<String,OpenApiResponse>',context!);
        Schemes = JsonConverters.fromJson(json['Schemes'],'List<String>',context!);
        Deprecated = json['Deprecated'];
        Security = JsonConverters.fromJson(json['Security'],'List<Map<String,List<String>>>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Tags': JsonConverters.toJson(Tags,'List<String>',context!),
        'Summary': Summary,
        'Description': Description,
        'ExternalDocs': JsonConverters.toJson(ExternalDocs,'OpenApiExternalDocumentation',context!),
        'OperationId': OperationId,
        'Consumes': JsonConverters.toJson(Consumes,'List<String>',context!),
        'Produces': JsonConverters.toJson(Produces,'List<String>',context!),
        'Parameters': JsonConverters.toJson(Parameters,'List<OpenApiParameter>',context!),
        'Responses': JsonConverters.toJson(Responses,'OrderedDictionary<String,OpenApiResponse>',context!),
        'Schemes': JsonConverters.toJson(Schemes,'List<String>',context!),
        'Deprecated': Deprecated,
        'Security': JsonConverters.toJson(Security,'List<Map<String,List<String>>>',context!)
    };

    getTypeName() => "OpenApiOperation";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiPath implements IConvertible
{
    // @DataMember(Name="$ref")
    String? Ref;

    // @DataMember(Name="get")
    OpenApiOperation? Get;

    // @DataMember(Name="put")
    OpenApiOperation? Put;

    // @DataMember(Name="post")
    OpenApiOperation? Post;

    // @DataMember(Name="delete")
    OpenApiOperation? Delete;

    // @DataMember(Name="options")
    OpenApiOperation? Options;

    // @DataMember(Name="head")
    OpenApiOperation? Head;

    // @DataMember(Name="patch")
    OpenApiOperation? Patch;

    // @DataMember(Name="parameters")
    List<OpenApiParameter>? Parameters;

    OpenApiPath({this.Ref,this.Get,this.Put,this.Post,this.Delete,this.Options,this.Head,this.Patch,this.Parameters});
    OpenApiPath.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Ref = json['Ref'];
        Get = JsonConverters.fromJson(json['Get'],'OpenApiOperation',context!);
        Put = JsonConverters.fromJson(json['Put'],'OpenApiOperation',context!);
        Post = JsonConverters.fromJson(json['Post'],'OpenApiOperation',context!);
        Delete = JsonConverters.fromJson(json['Delete'],'OpenApiOperation',context!);
        Options = JsonConverters.fromJson(json['Options'],'OpenApiOperation',context!);
        Head = JsonConverters.fromJson(json['Head'],'OpenApiOperation',context!);
        Patch = JsonConverters.fromJson(json['Patch'],'OpenApiOperation',context!);
        Parameters = JsonConverters.fromJson(json['Parameters'],'List<OpenApiParameter>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Ref': Ref,
        'Get': JsonConverters.toJson(Get,'OpenApiOperation',context!),
        'Put': JsonConverters.toJson(Put,'OpenApiOperation',context!),
        'Post': JsonConverters.toJson(Post,'OpenApiOperation',context!),
        'Delete': JsonConverters.toJson(Delete,'OpenApiOperation',context!),
        'Options': JsonConverters.toJson(Options,'OpenApiOperation',context!),
        'Head': JsonConverters.toJson(Head,'OpenApiOperation',context!),
        'Patch': JsonConverters.toJson(Patch,'OpenApiOperation',context!),
        'Parameters': JsonConverters.toJson(Parameters,'List<OpenApiParameter>',context!)
    };

    getTypeName() => "OpenApiPath";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiSecuritySchema implements IConvertible
{
    // @DataMember(Name="type")
    String? Type;

    // @DataMember(Name="description")
    String? Description;

    // @DataMember(Name="name")
    String? Name;

    // @DataMember(Name="in")
    String? In;

    // @DataMember(Name="flow")
    String? Flow;

    // @DataMember(Name="authorizationUrl")
    String? AuthorizationUrl;

    // @DataMember(Name="tokenUrl")
    String? TokenUrl;

    // @DataMember(Name="scopes")
    Map<String,String?>? Scopes;

    OpenApiSecuritySchema({this.Type,this.Description,this.Name,this.In,this.Flow,this.AuthorizationUrl,this.TokenUrl,this.Scopes});
    OpenApiSecuritySchema.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Type = json['Type'];
        Description = json['Description'];
        Name = json['Name'];
        In = json['In'];
        Flow = json['Flow'];
        AuthorizationUrl = json['AuthorizationUrl'];
        TokenUrl = json['TokenUrl'];
        Scopes = JsonConverters.toStringMap(json['Scopes']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Type': Type,
        'Description': Description,
        'Name': Name,
        'In': In,
        'Flow': Flow,
        'AuthorizationUrl': AuthorizationUrl,
        'TokenUrl': TokenUrl,
        'Scopes': Scopes
    };

    getTypeName() => "OpenApiSecuritySchema";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiTag implements IConvertible
{
    // @DataMember(Name="name")
    String? Name;

    // @DataMember(Name="description")
    String? Description;

    // @DataMember(Name="externalDocs")
    OpenApiExternalDocumentation? ExternalDocs;

    OpenApiTag({this.Name,this.Description,this.ExternalDocs});
    OpenApiTag.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Description = json['Description'];
        ExternalDocs = JsonConverters.fromJson(json['ExternalDocs'],'OpenApiExternalDocumentation',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Description': Description,
        'ExternalDocs': JsonConverters.toJson(ExternalDocs,'OpenApiExternalDocumentation',context!)
    };

    getTypeName() => "OpenApiTag";
    TypeContext? context = _ctx;
}

// @DataContract
class OpenApiDeclaration implements IConvertible
{
    // @DataMember(Name="swagger")
    String? Swagger;

    // @DataMember(Name="info")
    OpenApiInfo? Info;

    // @DataMember(Name="host")
    String? Host;

    // @DataMember(Name="basePath")
    String? BasePath;

    // @DataMember(Name="schemes")
    List<String>? Schemes;

    // @DataMember(Name="consumes")
    List<String>? Consumes;

    // @DataMember(Name="produces")
    List<String>? Produces;

    // @DataMember(Name="paths")
    OrderedDictionary<String,OpenApiPath>? Paths;

    // @DataMember(Name="definitions")
    Map<String,OpenApiSchema?>? Definitions;

    // @DataMember(Name="parameters")
    Map<String,OpenApiParameter?>? Parameters;

    // @DataMember(Name="responses")
    OrderedDictionary<String,OpenApiResponse>? Responses;

    // @DataMember(Name="securityDefinitions")
    Map<String,OpenApiSecuritySchema?>? SecurityDefinitions;

    // @DataMember(Name="security")
    List<Map<String,List<String>>>? Security;

    // @DataMember(Name="tags")
    List<OpenApiTag>? Tags;

    // @DataMember(Name="externalDocs")
    OpenApiExternalDocumentation? ExternalDocs;

    OpenApiDeclaration({this.Swagger,this.Info,this.Host,this.BasePath,this.Schemes,this.Consumes,this.Produces,this.Paths,this.Definitions,this.Parameters,this.Responses,this.SecurityDefinitions,this.Security,this.Tags,this.ExternalDocs});
    OpenApiDeclaration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Swagger = json['Swagger'];
        Info = JsonConverters.fromJson(json['Info'],'OpenApiInfo',context!);
        Host = json['Host'];
        BasePath = json['BasePath'];
        Schemes = JsonConverters.fromJson(json['Schemes'],'List<String>',context!);
        Consumes = JsonConverters.fromJson(json['Consumes'],'List<String>',context!);
        Produces = JsonConverters.fromJson(json['Produces'],'List<String>',context!);
        Paths = JsonConverters.fromJson(json['Paths'],'OrderedDictionary<String,OpenApiPath>',context!);
        Definitions = JsonConverters.fromJson(json['Definitions'],'Map<String,OpenApiSchema?>',context!);
        Parameters = JsonConverters.fromJson(json['Parameters'],'Map<String,OpenApiParameter?>',context!);
        Responses = JsonConverters.fromJson(json['Responses'],'OrderedDictionary<String,OpenApiResponse>',context!);
        SecurityDefinitions = JsonConverters.fromJson(json['SecurityDefinitions'],'Map<String,OpenApiSecuritySchema?>',context!);
        Security = JsonConverters.fromJson(json['Security'],'List<Map<String,List<String>>>',context!);
        Tags = JsonConverters.fromJson(json['Tags'],'List<OpenApiTag>',context!);
        ExternalDocs = JsonConverters.fromJson(json['ExternalDocs'],'OpenApiExternalDocumentation',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Swagger': Swagger,
        'Info': JsonConverters.toJson(Info,'OpenApiInfo',context!),
        'Host': Host,
        'BasePath': BasePath,
        'Schemes': JsonConverters.toJson(Schemes,'List<String>',context!),
        'Consumes': JsonConverters.toJson(Consumes,'List<String>',context!),
        'Produces': JsonConverters.toJson(Produces,'List<String>',context!),
        'Paths': JsonConverters.toJson(Paths,'OrderedDictionary<String,OpenApiPath>',context!),
        'Definitions': JsonConverters.toJson(Definitions,'Map<String,OpenApiSchema?>',context!),
        'Parameters': JsonConverters.toJson(Parameters,'Map<String,OpenApiParameter?>',context!),
        'Responses': JsonConverters.toJson(Responses,'OrderedDictionary<String,OpenApiResponse>',context!),
        'SecurityDefinitions': JsonConverters.toJson(SecurityDefinitions,'Map<String,OpenApiSecuritySchema?>',context!),
        'Security': JsonConverters.toJson(Security,'List<Map<String,List<String>>>',context!),
        'Tags': JsonConverters.toJson(Tags,'List<OpenApiTag>',context!),
        'ExternalDocs': JsonConverters.toJson(ExternalDocs,'OpenApiExternalDocumentation',context!)
    };

    getTypeName() => "OpenApiDeclaration";
    TypeContext? context = _ctx;
}

class OpenApiSpecRequest implements IConvertible
{
    // @DataMember(Name="apiKey")
    String? ApiKey;

    // @DataMember(Name="category")
    String? Category;

    // @DataMember(Name="ver")
    String? Version;

    OpenApiSpecRequest({this.ApiKey,this.Category,this.Version});
    OpenApiSpecRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ApiKey = json['ApiKey'];
        Category = json['Category'];
        Version = json['Version'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ApiKey': ApiKey,
        'Category': Category,
        'Version': Version
    };

    getTypeName() => "OpenApiSpecRequest";
    TypeContext? context = _ctx;
}

class OrderedDictionary<TKey,TValue> implements IConvertible
{
    OrderedDictionary();
    OrderedDictionary.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    getTypeName() => "OrderedDictionary<$TKey,$TValue>";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'devapi.billhighway.com', types: <String, TypeInfo> {
    'OpenApiContact': TypeInfo(TypeOf.Class, create:() => OpenApiContact()),
    'OpenApiLicense': TypeInfo(TypeOf.Class, create:() => OpenApiLicense()),
    'OpenApiInfo': TypeInfo(TypeOf.Class, create:() => OpenApiInfo()),
    'OpenApiExternalDocumentation': TypeInfo(TypeOf.Class, create:() => OpenApiExternalDocumentation()),
    'OpenApiDataTypeSchema': TypeInfo(TypeOf.AbstractClass),
    'Map<String,dynamic?>': TypeInfo(TypeOf.Class, create:() => Map<String,dynamic?>()),
    'OpenApiXmlObject': TypeInfo(TypeOf.Class, create:() => OpenApiXmlObject()),
    'OpenApiProperty': TypeInfo(TypeOf.Class, create:() => OpenApiProperty()),
    'OpenApiSchema': TypeInfo(TypeOf.Class, create:() => OpenApiSchema()),
    'OrderedDictionary<String,OpenApiProperty>': TypeInfo(TypeOf.Class, create:() => OrderedDictionary<String,OpenApiProperty>()),
    'OpenApiParameter': TypeInfo(TypeOf.Class, create:() => OpenApiParameter()),
    'OpenApiResponse': TypeInfo(TypeOf.Class, create:() => OpenApiResponse()),
    'Map<String,OpenApiProperty?>': TypeInfo(TypeOf.Class, create:() => Map<String,OpenApiProperty?>()),
    'OpenApiOperation': TypeInfo(TypeOf.Class, create:() => OpenApiOperation()),
    'List<OpenApiParameter>': TypeInfo(TypeOf.Class, create:() => <OpenApiParameter>[]),
    'OrderedDictionary<String,OpenApiResponse>': TypeInfo(TypeOf.Class, create:() => OrderedDictionary<String,OpenApiResponse>()),
    'List<Map<String,List<String>>>': TypeInfo(TypeOf.Class, create:() => <Map<String,List<String>>>[]),
    'Map<String,List<String>>': TypeInfo(TypeOf.Class, create:() => Map<String,List<String>>()),
    'OpenApiPath': TypeInfo(TypeOf.Class, create:() => OpenApiPath()),
    'OpenApiSecuritySchema': TypeInfo(TypeOf.Class, create:() => OpenApiSecuritySchema()),
    'OpenApiTag': TypeInfo(TypeOf.Class, create:() => OpenApiTag()),
    'OpenApiDeclaration': TypeInfo(TypeOf.Class, create:() => OpenApiDeclaration()),
    'OrderedDictionary<String,OpenApiPath>': TypeInfo(TypeOf.Class, create:() => OrderedDictionary<String,OpenApiPath>()),
    'Map<String,OpenApiSchema?>': TypeInfo(TypeOf.Class, create:() => Map<String,OpenApiSchema?>()),
    'Map<String,OpenApiParameter?>': TypeInfo(TypeOf.Class, create:() => Map<String,OpenApiParameter?>()),
    'Map<String,OpenApiSecuritySchema?>': TypeInfo(TypeOf.Class, create:() => Map<String,OpenApiSecuritySchema?>()),
    'List<OpenApiTag>': TypeInfo(TypeOf.Class, create:() => <OpenApiTag>[]),
    'OpenApiSpecRequest': TypeInfo(TypeOf.Class, create:() => OpenApiSpecRequest()),
    'OrderedDictionary<TKey,TValue>': TypeInfo(TypeOf.GenericDef,create:() => OrderedDictionary()),
});

Dart OpenApiSpecRequest DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv

HTTP + JSV

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

GET /oas HTTP/1.1 
Host: devapi.billhighway.com 
Accept: text/jsv

HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	swagger: 2.0,
	info: 
	{
		title: String,
		description: String,
		termsOfServiceUrl: String,
		contact: 
		{
			name: String,
			url: String,
			email: String
		},
		license: 
		{
			name: String,
			url: String
		},
		version: String
	},
	host: String,
	basePath: String,
	schemes: 
	[
		String
	],
	consumes: 
	[
		String
	],
	produces: 
	[
		String
	],
	paths: 
	{
		String: 
		{
			$ref: String,
			get: 
			{
				tags: 
				[
					String
				],
				summary: String,
				description: String,
				externalDocs: 
				{
					description: String,
					url: String
				},
				operationId: String,
				consumes: 
				[
					String
				],
				produces: 
				[
					String
				],
				parameters: 
				[
					{
						name: String,
						in: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						allowEmptyValue: False,
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				],
				responses: 
				{
					String: 
					{
						description: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						headers: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						examples: 
						{
							String: String
						}
					}
				},
				schemes: 
				[
					String
				],
				deprecated: False,
				security: 
				[
					{
						String: 
						[
							String
						]
					}
				]
			},
			put: 
			{
				tags: 
				[
					String
				],
				summary: String,
				description: String,
				externalDocs: 
				{
					description: String,
					url: String
				},
				operationId: String,
				consumes: 
				[
					String
				],
				produces: 
				[
					String
				],
				parameters: 
				[
					{
						name: String,
						in: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						allowEmptyValue: False,
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				],
				responses: 
				{
					String: 
					{
						description: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						headers: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						examples: 
						{
							String: String
						}
					}
				},
				schemes: 
				[
					String
				],
				deprecated: False,
				security: 
				[
					{
						String: 
						[
							String
						]
					}
				]
			},
			post: 
			{
				tags: 
				[
					String
				],
				summary: String,
				description: String,
				externalDocs: 
				{
					description: String,
					url: String
				},
				operationId: String,
				consumes: 
				[
					String
				],
				produces: 
				[
					String
				],
				parameters: 
				[
					{
						name: String,
						in: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						allowEmptyValue: False,
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				],
				responses: 
				{
					String: 
					{
						description: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						headers: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						examples: 
						{
							String: String
						}
					}
				},
				schemes: 
				[
					String
				],
				deprecated: False,
				security: 
				[
					{
						String: 
						[
							String
						]
					}
				]
			},
			delete: 
			{
				tags: 
				[
					String
				],
				summary: String,
				description: String,
				externalDocs: 
				{
					description: String,
					url: String
				},
				operationId: String,
				consumes: 
				[
					String
				],
				produces: 
				[
					String
				],
				parameters: 
				[
					{
						name: String,
						in: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						allowEmptyValue: False,
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				],
				responses: 
				{
					String: 
					{
						description: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						headers: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						examples: 
						{
							String: String
						}
					}
				},
				schemes: 
				[
					String
				],
				deprecated: False,
				security: 
				[
					{
						String: 
						[
							String
						]
					}
				]
			},
			options: 
			{
				tags: 
				[
					String
				],
				summary: String,
				description: String,
				externalDocs: 
				{
					description: String,
					url: String
				},
				operationId: String,
				consumes: 
				[
					String
				],
				produces: 
				[
					String
				],
				parameters: 
				[
					{
						name: String,
						in: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						allowEmptyValue: False,
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				],
				responses: 
				{
					String: 
					{
						description: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						headers: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						examples: 
						{
							String: String
						}
					}
				},
				schemes: 
				[
					String
				],
				deprecated: False,
				security: 
				[
					{
						String: 
						[
							String
						]
					}
				]
			},
			head: 
			{
				tags: 
				[
					String
				],
				summary: String,
				description: String,
				externalDocs: 
				{
					description: String,
					url: String
				},
				operationId: String,
				consumes: 
				[
					String
				],
				produces: 
				[
					String
				],
				parameters: 
				[
					{
						name: String,
						in: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						allowEmptyValue: False,
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				],
				responses: 
				{
					String: 
					{
						description: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						headers: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						examples: 
						{
							String: String
						}
					}
				},
				schemes: 
				[
					String
				],
				deprecated: False,
				security: 
				[
					{
						String: 
						[
							String
						]
					}
				]
			},
			patch: 
			{
				tags: 
				[
					String
				],
				summary: String,
				description: String,
				externalDocs: 
				{
					description: String,
					url: String
				},
				operationId: String,
				consumes: 
				[
					String
				],
				produces: 
				[
					String
				],
				parameters: 
				[
					{
						name: String,
						in: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						allowEmptyValue: False,
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				],
				responses: 
				{
					String: 
					{
						description: String,
						schema: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								allOf: 
								{
									title: String,
									discriminator: String,
									readOnly: False,
									xml: 
									{
										name: String,
										namespace: String,
										prefix: String,
										attribute: False,
										wrapped: False
									},
									externalDocs: 
									{
										description: String,
										url: String
									},
									example: String,
									required: 
									[
										String
									],
									properties: 
									{
										String: 
										{
											$ref: String,
											description: String,
											type: String,
											format: String,
											items: 
											{
												String: {}
											},
											collectionFormat: String,
											default: String,
											maximum: 0,
											exclusiveMaximum: False,
											minimum: 0,
											exclusiveMinimum: False,
											maxLength: 0,
											minLength: 0,
											pattern: String,
											maxItems: 0,
											minItems: 0,
											uniqueItems: False,
											maxProperties: String,
											minProperties: String,
											required: False,
											enum: 
											[
												String
											],
											multipleOf: 0,
											x-nullable: False
										}
									},
									additionalProperties: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									},
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						headers: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						examples: 
						{
							String: String
						}
					}
				},
				schemes: 
				[
					String
				],
				deprecated: False,
				security: 
				[
					{
						String: 
						[
							String
						]
					}
				]
			},
			parameters: 
			[
				{
					name: String,
					in: String,
					schema: 
					{
						title: String,
						discriminator: String,
						readOnly: False,
						xml: 
						{
							name: String,
							namespace: String,
							prefix: String,
							attribute: False,
							wrapped: False
						},
						externalDocs: 
						{
							description: String,
							url: String
						},
						example: String,
						required: 
						[
							String
						],
						allOf: 
						{
							title: String,
							discriminator: String,
							readOnly: False,
							xml: 
							{
								name: String,
								namespace: String,
								prefix: String,
								attribute: False,
								wrapped: False
							},
							externalDocs: 
							{
								description: String,
								url: String
							},
							example: String,
							required: 
							[
								String
							],
							allOf: 
							{
								title: String,
								discriminator: String,
								readOnly: False,
								xml: 
								{
									name: String,
									namespace: String,
									prefix: String,
									attribute: False,
									wrapped: False
								},
								externalDocs: 
								{
									description: String,
									url: String
								},
								example: String,
								required: 
								[
									String
								],
								properties: 
								{
									String: 
									{
										$ref: String,
										description: String,
										type: String,
										format: String,
										items: 
										{
											String: {}
										},
										collectionFormat: String,
										default: String,
										maximum: 0,
										exclusiveMaximum: False,
										minimum: 0,
										exclusiveMinimum: False,
										maxLength: 0,
										minLength: 0,
										pattern: String,
										maxItems: 0,
										minItems: 0,
										uniqueItems: False,
										maxProperties: String,
										minProperties: String,
										required: False,
										enum: 
										[
											String
										],
										multipleOf: 0,
										x-nullable: False
									}
								},
								additionalProperties: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								},
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							properties: 
							{
								String: 
								{
									$ref: String,
									description: String,
									type: String,
									format: String,
									items: 
									{
										String: {}
									},
									collectionFormat: String,
									default: String,
									maximum: 0,
									exclusiveMaximum: False,
									minimum: 0,
									exclusiveMinimum: False,
									maxLength: 0,
									minLength: 0,
									pattern: String,
									maxItems: 0,
									minItems: 0,
									uniqueItems: False,
									maxProperties: String,
									minProperties: String,
									required: False,
									enum: 
									[
										String
									],
									multipleOf: 0,
									x-nullable: False
								}
							},
							additionalProperties: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							},
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						properties: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						additionalProperties: 
						{
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					},
					allowEmptyValue: False,
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				}
			]
		}
	},
	definitions: 
	{
		String: 
		{
			title: String,
			discriminator: String,
			readOnly: False,
			xml: 
			{
				name: String,
				namespace: String,
				prefix: String,
				attribute: False,
				wrapped: False
			},
			externalDocs: 
			{
				description: String,
				url: String
			},
			example: String,
			required: 
			[
				String
			],
			allOf: 
			{
				title: String,
				discriminator: String,
				readOnly: False,
				xml: 
				{
					name: String,
					namespace: String,
					prefix: String,
					attribute: False,
					wrapped: False
				},
				externalDocs: 
				{
					description: String,
					url: String
				},
				example: String,
				required: 
				[
					String
				],
				allOf: 
				{
					title: String,
					discriminator: String,
					readOnly: False,
					xml: 
					{
						name: String,
						namespace: String,
						prefix: String,
						attribute: False,
						wrapped: False
					},
					externalDocs: 
					{
						description: String,
						url: String
					},
					example: String,
					required: 
					[
						String
					],
					properties: 
					{
						String: 
						{
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						}
					},
					additionalProperties: 
					{
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					},
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				},
				properties: 
				{
					String: 
					{
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				},
				additionalProperties: 
				{
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				},
				$ref: String,
				description: String,
				type: String,
				format: String,
				items: 
				{
					String: {}
				},
				collectionFormat: String,
				default: String,
				maximum: 0,
				exclusiveMaximum: False,
				minimum: 0,
				exclusiveMinimum: False,
				maxLength: 0,
				minLength: 0,
				pattern: String,
				maxItems: 0,
				minItems: 0,
				uniqueItems: False,
				maxProperties: String,
				minProperties: String,
				required: False,
				enum: 
				[
					String
				],
				multipleOf: 0,
				x-nullable: False
			},
			properties: 
			{
				String: 
				{
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				}
			},
			additionalProperties: 
			{
				$ref: String,
				description: String,
				type: String,
				format: String,
				items: 
				{
					String: {}
				},
				collectionFormat: String,
				default: String,
				maximum: 0,
				exclusiveMaximum: False,
				minimum: 0,
				exclusiveMinimum: False,
				maxLength: 0,
				minLength: 0,
				pattern: String,
				maxItems: 0,
				minItems: 0,
				uniqueItems: False,
				maxProperties: String,
				minProperties: String,
				required: False,
				enum: 
				[
					String
				],
				multipleOf: 0,
				x-nullable: False
			},
			$ref: String,
			description: String,
			type: String,
			format: String,
			items: 
			{
				String: {}
			},
			collectionFormat: String,
			default: String,
			maximum: 0,
			exclusiveMaximum: False,
			minimum: 0,
			exclusiveMinimum: False,
			maxLength: 0,
			minLength: 0,
			pattern: String,
			maxItems: 0,
			minItems: 0,
			uniqueItems: False,
			maxProperties: String,
			minProperties: String,
			required: False,
			enum: 
			[
				String
			],
			multipleOf: 0,
			x-nullable: False
		}
	},
	parameters: 
	{
		String: 
		{
			name: String,
			in: String,
			schema: 
			{
				title: String,
				discriminator: String,
				readOnly: False,
				xml: 
				{
					name: String,
					namespace: String,
					prefix: String,
					attribute: False,
					wrapped: False
				},
				externalDocs: 
				{
					description: String,
					url: String
				},
				example: String,
				required: 
				[
					String
				],
				allOf: 
				{
					title: String,
					discriminator: String,
					readOnly: False,
					xml: 
					{
						name: String,
						namespace: String,
						prefix: String,
						attribute: False,
						wrapped: False
					},
					externalDocs: 
					{
						description: String,
						url: String
					},
					example: String,
					required: 
					[
						String
					],
					allOf: 
					{
						title: String,
						discriminator: String,
						readOnly: False,
						xml: 
						{
							name: String,
							namespace: String,
							prefix: String,
							attribute: False,
							wrapped: False
						},
						externalDocs: 
						{
							description: String,
							url: String
						},
						example: String,
						required: 
						[
							String
						],
						properties: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						additionalProperties: 
						{
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					},
					properties: 
					{
						String: 
						{
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						}
					},
					additionalProperties: 
					{
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					},
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				},
				properties: 
				{
					String: 
					{
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				},
				additionalProperties: 
				{
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				},
				$ref: String,
				description: String,
				type: String,
				format: String,
				items: 
				{
					String: {}
				},
				collectionFormat: String,
				default: String,
				maximum: 0,
				exclusiveMaximum: False,
				minimum: 0,
				exclusiveMinimum: False,
				maxLength: 0,
				minLength: 0,
				pattern: String,
				maxItems: 0,
				minItems: 0,
				uniqueItems: False,
				maxProperties: String,
				minProperties: String,
				required: False,
				enum: 
				[
					String
				],
				multipleOf: 0,
				x-nullable: False
			},
			allowEmptyValue: False,
			$ref: String,
			description: String,
			type: String,
			format: String,
			items: 
			{
				String: {}
			},
			collectionFormat: String,
			default: String,
			maximum: 0,
			exclusiveMaximum: False,
			minimum: 0,
			exclusiveMinimum: False,
			maxLength: 0,
			minLength: 0,
			pattern: String,
			maxItems: 0,
			minItems: 0,
			uniqueItems: False,
			maxProperties: String,
			minProperties: String,
			required: False,
			enum: 
			[
				String
			],
			multipleOf: 0,
			x-nullable: False
		}
	},
	responses: 
	{
		String: 
		{
			description: String,
			schema: 
			{
				title: String,
				discriminator: String,
				readOnly: False,
				xml: 
				{
					name: String,
					namespace: String,
					prefix: String,
					attribute: False,
					wrapped: False
				},
				externalDocs: 
				{
					description: String,
					url: String
				},
				example: String,
				required: 
				[
					String
				],
				allOf: 
				{
					title: String,
					discriminator: String,
					readOnly: False,
					xml: 
					{
						name: String,
						namespace: String,
						prefix: String,
						attribute: False,
						wrapped: False
					},
					externalDocs: 
					{
						description: String,
						url: String
					},
					example: String,
					required: 
					[
						String
					],
					allOf: 
					{
						title: String,
						discriminator: String,
						readOnly: False,
						xml: 
						{
							name: String,
							namespace: String,
							prefix: String,
							attribute: False,
							wrapped: False
						},
						externalDocs: 
						{
							description: String,
							url: String
						},
						example: String,
						required: 
						[
							String
						],
						properties: 
						{
							String: 
							{
								$ref: String,
								description: String,
								type: String,
								format: String,
								items: 
								{
									String: {}
								},
								collectionFormat: String,
								default: String,
								maximum: 0,
								exclusiveMaximum: False,
								minimum: 0,
								exclusiveMinimum: False,
								maxLength: 0,
								minLength: 0,
								pattern: String,
								maxItems: 0,
								minItems: 0,
								uniqueItems: False,
								maxProperties: String,
								minProperties: String,
								required: False,
								enum: 
								[
									String
								],
								multipleOf: 0,
								x-nullable: False
							}
						},
						additionalProperties: 
						{
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						},
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					},
					properties: 
					{
						String: 
						{
							$ref: String,
							description: String,
							type: String,
							format: String,
							items: 
							{
								String: {}
							},
							collectionFormat: String,
							default: String,
							maximum: 0,
							exclusiveMaximum: False,
							minimum: 0,
							exclusiveMinimum: False,
							maxLength: 0,
							minLength: 0,
							pattern: String,
							maxItems: 0,
							minItems: 0,
							uniqueItems: False,
							maxProperties: String,
							minProperties: String,
							required: False,
							enum: 
							[
								String
							],
							multipleOf: 0,
							x-nullable: False
						}
					},
					additionalProperties: 
					{
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					},
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				},
				properties: 
				{
					String: 
					{
						$ref: String,
						description: String,
						type: String,
						format: String,
						items: 
						{
							String: {}
						},
						collectionFormat: String,
						default: String,
						maximum: 0,
						exclusiveMaximum: False,
						minimum: 0,
						exclusiveMinimum: False,
						maxLength: 0,
						minLength: 0,
						pattern: String,
						maxItems: 0,
						minItems: 0,
						uniqueItems: False,
						maxProperties: String,
						minProperties: String,
						required: False,
						enum: 
						[
							String
						],
						multipleOf: 0,
						x-nullable: False
					}
				},
				additionalProperties: 
				{
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				},
				$ref: String,
				description: String,
				type: String,
				format: String,
				items: 
				{
					String: {}
				},
				collectionFormat: String,
				default: String,
				maximum: 0,
				exclusiveMaximum: False,
				minimum: 0,
				exclusiveMinimum: False,
				maxLength: 0,
				minLength: 0,
				pattern: String,
				maxItems: 0,
				minItems: 0,
				uniqueItems: False,
				maxProperties: String,
				minProperties: String,
				required: False,
				enum: 
				[
					String
				],
				multipleOf: 0,
				x-nullable: False
			},
			headers: 
			{
				String: 
				{
					$ref: String,
					description: String,
					type: String,
					format: String,
					items: 
					{
						String: {}
					},
					collectionFormat: String,
					default: String,
					maximum: 0,
					exclusiveMaximum: False,
					minimum: 0,
					exclusiveMinimum: False,
					maxLength: 0,
					minLength: 0,
					pattern: String,
					maxItems: 0,
					minItems: 0,
					uniqueItems: False,
					maxProperties: String,
					minProperties: String,
					required: False,
					enum: 
					[
						String
					],
					multipleOf: 0,
					x-nullable: False
				}
			},
			examples: 
			{
				String: String
			}
		}
	},
	securityDefinitions: 
	{
		String: 
		{
			type: String,
			description: String,
			name: String,
			in: String,
			flow: String,
			authorizationUrl: String,
			tokenUrl: String,
			scopes: 
			{
				String: String
			}
		}
	},
	security: 
	[
		{
			String: 
			[
				String
			]
		}
	],
	tags: 
	[
		{
			name: String,
			description: String,
			externalDocs: 
			{
				description: String,
				url: String
			}
		}
	],
	externalDocs: 
	{
		description: String,
		url: String
	}
}