/* Options:
Date: 2024-09-30 10:16:42
Version: 8.23
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.bokamera.se

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

import 'package:servicestack/servicestack.dart';

abstract class ICompany
{
    String? CompanyId;
}

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

    Map<String, dynamic> toJson() => {};
    getTypeName() => "BaseModel";
    TypeContext? context = _ctx;
}

class DashboardMessageType extends BaseModel implements IConvertible
{
    // @Required()
    String? Name;

    // @Required()
    String? Description;

    // @Required()
    String? Image;

    bool? ApplicationMessage;
    // @Required()
    String? Color;

    // @Required()
    String? Icon;

    DateTime? ModifiedDate;
    int? Id;

    DashboardMessageType({this.Name,this.Description,this.Image,this.ApplicationMessage,this.Color,this.Icon,this.ModifiedDate,this.Id});
    DashboardMessageType.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Name = json['Name'];
        Description = json['Description'];
        Image = json['Image'];
        ApplicationMessage = json['ApplicationMessage'];
        Color = json['Color'];
        Icon = json['Icon'];
        ModifiedDate = JsonConverters.fromJson(json['ModifiedDate'],'DateTime',context!);
        Id = json['Id'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Name': Name,
        'Description': Description,
        'Image': Image,
        'ApplicationMessage': ApplicationMessage,
        'Color': Color,
        'Icon': Icon,
        'ModifiedDate': JsonConverters.toJson(ModifiedDate,'DateTime',context!),
        'Id': Id
    });

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

class DashboardMessage extends BaseModel implements IConvertible
{
    // @References(typeof(DashboardMessageType))
    int? MessageTypeId;

    DashboardMessageType? MessageType;
    // @Required()
    String? CompanyId;

    int? Id;
    // @Required()
    String? Title;

    // @Required()
    String? Body;

    // @Required()
    bool? Important;

    // @Required()
    DateTime? VisibleFrom;

    // @Required()
    DateTime? VisibleTo;

    // @Required()
    DateTime? Created;

    int? SupportCaseId;
    DateTime? ModifiedDate;

    DashboardMessage({this.MessageTypeId,this.MessageType,this.CompanyId,this.Id,this.Title,this.Body,this.Important,this.VisibleFrom,this.VisibleTo,this.Created,this.SupportCaseId,this.ModifiedDate});
    DashboardMessage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        MessageTypeId = json['MessageTypeId'];
        MessageType = JsonConverters.fromJson(json['MessageType'],'DashboardMessageType',context!);
        CompanyId = json['CompanyId'];
        Id = json['Id'];
        Title = json['Title'];
        Body = json['Body'];
        Important = json['Important'];
        VisibleFrom = JsonConverters.fromJson(json['VisibleFrom'],'DateTime',context!);
        VisibleTo = JsonConverters.fromJson(json['VisibleTo'],'DateTime',context!);
        Created = JsonConverters.fromJson(json['Created'],'DateTime',context!);
        SupportCaseId = json['SupportCaseId'];
        ModifiedDate = JsonConverters.fromJson(json['ModifiedDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'MessageTypeId': MessageTypeId,
        'MessageType': JsonConverters.toJson(MessageType,'DashboardMessageType',context!),
        'CompanyId': CompanyId,
        'Id': Id,
        'Title': Title,
        'Body': Body,
        'Important': Important,
        'VisibleFrom': JsonConverters.toJson(VisibleFrom,'DateTime',context!),
        'VisibleTo': JsonConverters.toJson(VisibleTo,'DateTime',context!),
        'Created': JsonConverters.toJson(Created,'DateTime',context!),
        'SupportCaseId': SupportCaseId,
        'ModifiedDate': JsonConverters.toJson(ModifiedDate,'DateTime',context!)
    });

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

class DasboardMessageTypeResponse implements IConvertible
{
    /**
    * The message type id
    */
    // @ApiMember(Description="The message type id")
    int? Id;

    /**
    * The message type name
    */
    // @ApiMember(Description="The message type name")
    String? Name;

    /**
    * The message type description
    */
    // @ApiMember(Description="The message type description")
    String? Description;

    /**
    * The message type image
    */
    // @ApiMember(Description="The message type image")
    String? ImageUrl;

    /**
    * If the message type is a application message
    */
    // @ApiMember(Description="If the message type is a application message")
    bool? ApplicationMessage;

    /**
    * The message type icon
    */
    // @ApiMember(Description="The message type icon")
    String? Icon;

    /**
    * The message type color
    */
    // @ApiMember(Description="The message type color")
    String? Color;

    DasboardMessageTypeResponse({this.Id,this.Name,this.Description,this.ImageUrl,this.ApplicationMessage,this.Icon,this.Color});
    DasboardMessageTypeResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Name = json['Name'];
        Description = json['Description'];
        ImageUrl = json['ImageUrl'];
        ApplicationMessage = json['ApplicationMessage'];
        Icon = json['Icon'];
        Color = json['Color'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'Description': Description,
        'ImageUrl': ImageUrl,
        'ApplicationMessage': ApplicationMessage,
        'Icon': Icon,
        'Color': Color
    };

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

class DashboardMessageQueryResponse implements IConvertible
{
    /**
    * The message id
    */
    // @ApiMember(Description="The message id")
    int? Id;

    /**
    * The message title.
    */
    // @ApiMember(Description="The message title.")
    String? Title;

    /**
    * The message body.
    */
    // @ApiMember(Description="The message body.")
    String? Body;

    /**
    * If the message is important.
    */
    // @ApiMember(Description="If the message is important.")
    bool? Important;

    /**
    * If the message visible from date.
    */
    // @ApiMember(Description="If the message visible from date.")
    DateTime? VisibleFrom;

    /**
    * If the message visible to date.
    */
    // @ApiMember(Description="If the message visible to date.")
    DateTime? VisibleTo;

    /**
    * If the message created date.
    */
    // @ApiMember(Description="If the message created date.")
    DateTime? Created;

    /**
    * If the message type id.
    */
    // @ApiMember(Description="If the message type id.")
    int? MessageTypeId;

    /**
    * If the message is connected to a support case.
    */
    // @ApiMember(Description="If the message is connected to a support case.")
    int? SupportCaseId;

    /**
    * If the message type information.
    */
    // @ApiMember(Description="If the message type information.")
    DasboardMessageTypeResponse? MessageType;

    DashboardMessageQueryResponse({this.Id,this.Title,this.Body,this.Important,this.VisibleFrom,this.VisibleTo,this.Created,this.MessageTypeId,this.SupportCaseId,this.MessageType});
    DashboardMessageQueryResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Title = json['Title'];
        Body = json['Body'];
        Important = json['Important'];
        VisibleFrom = JsonConverters.fromJson(json['VisibleFrom'],'DateTime',context!);
        VisibleTo = JsonConverters.fromJson(json['VisibleTo'],'DateTime',context!);
        Created = JsonConverters.fromJson(json['Created'],'DateTime',context!);
        MessageTypeId = json['MessageTypeId'];
        SupportCaseId = json['SupportCaseId'];
        MessageType = JsonConverters.fromJson(json['MessageType'],'DasboardMessageTypeResponse',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Title': Title,
        'Body': Body,
        'Important': Important,
        'VisibleFrom': JsonConverters.toJson(VisibleFrom,'DateTime',context!),
        'VisibleTo': JsonConverters.toJson(VisibleTo,'DateTime',context!),
        'Created': JsonConverters.toJson(Created,'DateTime',context!),
        'MessageTypeId': MessageTypeId,
        'SupportCaseId': SupportCaseId,
        'MessageType': JsonConverters.toJson(MessageType,'DasboardMessageTypeResponse',context!)
    };

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

// @Route("/messages/dashboard", "GET")
// @ApiResponse(Description="You were unauthorized to call this service", StatusCode=401)
// @ValidateRequest(Validator="IsAuthenticated")
class DashboardMessageQuery extends QueryDb2<DashboardMessage,DashboardMessageQueryResponse> implements IReturn<QueryResponse<DashboardMessageQueryResponse>>, ICompany, IConvertible, IGet
{
    /**
    * The company id, if empty will use the company id for the user you are logged in with.
    */
    // @ApiMember(Description="The company id, if empty will use the company id for the user you are logged in with.", ParameterType="path")
    String? CompanyId;

    /**
    * If you want to filter on important messages only
    */
    // @ApiMember(DataType="boolean", Description="If you want to filter on important messages only", ParameterType="query")
    bool? Important;

    /**
    * Filter on Message Type Id
    */
    // @ApiMember(DataType="int", Description="Filter on Message Type Id", ParameterType="query")
    int? MessageTypeId;

    /**
    * If you want to include the message type information
    */
    // @ApiMember(DataType="boolean", Description="If you want to include the message type information", ParameterType="query")
    bool? IncludeMessageTypeInformation;

    ResponseStatus? ResponseStatus;

    DashboardMessageQuery({this.CompanyId,this.Important,this.MessageTypeId,this.IncludeMessageTypeInformation,this.ResponseStatus});
    DashboardMessageQuery.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        CompanyId = json['CompanyId'];
        Important = json['Important'];
        MessageTypeId = json['MessageTypeId'];
        IncludeMessageTypeInformation = json['IncludeMessageTypeInformation'];
        ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'CompanyId': CompanyId,
        'Important': Important,
        'MessageTypeId': MessageTypeId,
        'IncludeMessageTypeInformation': IncludeMessageTypeInformation,
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!)
    });

    createResponse() => QueryResponse<DashboardMessageQueryResponse>();
    getResponseTypeName() => "QueryResponse<DashboardMessageQueryResponse>";
    getTypeName() => "DashboardMessageQuery";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.bokamera.se', types: <String, TypeInfo> {
    'ICompany': TypeInfo(TypeOf.Interface),
    'BaseModel': TypeInfo(TypeOf.Class, create:() => BaseModel()),
    'DashboardMessageType': TypeInfo(TypeOf.Class, create:() => DashboardMessageType()),
    'DashboardMessage': TypeInfo(TypeOf.Class, create:() => DashboardMessage()),
    'DasboardMessageTypeResponse': TypeInfo(TypeOf.Class, create:() => DasboardMessageTypeResponse()),
    'DashboardMessageQueryResponse': TypeInfo(TypeOf.Class, create:() => DashboardMessageQueryResponse()),
    'QueryResponse<DashboardMessageQueryResponse>': TypeInfo(TypeOf.Class, create:() => QueryResponse<DashboardMessageQueryResponse>()),
    'DashboardMessageQuery': TypeInfo(TypeOf.Class, create:() => DashboardMessageQuery()),
    'List<DashboardMessageQueryResponse>': TypeInfo(TypeOf.Class, create:() => <DashboardMessageQueryResponse>[]),
});