/* Options:
Date: 2026-11-08 12:02:18
Version: 5.140
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://devapi.billhighway.com

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: OpenApiSpecRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

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;
}

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;
}

// @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;
}

// @Route("/oas", "GET")
class OpenApiSpecRequest implements IReturn<OpenApiDeclaration>, 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
    };

    createResponse() => OpenApiDeclaration();
    getResponseTypeName() => "OpenApiDeclaration";
    getTypeName() => "OpenApiSpecRequest";
    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()),
    'OrderedDictionary<TKey,TValue>': TypeInfo(TypeOf.GenericDef,create:() => OrderedDictionary()),
    '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()),
});