/* Options:
Date: 2026-06-13 13:36:12
Version: 8.80
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://riskstoreng-dev.nephila.com/api

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

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

enum ProcessingStatus
{
    New,
    Processing,
    Failed,
    Successful,
}

enum ResultOutputLevel
{
    NotSet,
    PortfolioMetrics,
    Curve,
    YLT,
    TailIntensity,
    DealYlt,
    DealElt,
    DealEltWithIndustryLoss,
    PortfolioElt,
    PortfolioEltWithIndustryLoss,
    EventSetGeneration,
    PortfolioRaps,
    DealRaps,
    PortfolioSepyIndustryLoss,
    DealSepyIndustryLoss,
}

class AnalysisPortfolioEventSetConfiguration implements IObjectWithId, IHasAnalysisId, IConvertible
{
    // @DataMember(Order=1)
    int? id;

    // @DataMember(Order=2)
    int? analysisId;

    // @DataMember(Order=3)
    int? analysisConfigurationId;

    // @DataMember(Order=4)
    String? portfolioName;

    // @DataMember(Order=5)
    String? modelId;

    // @DataMember(Order=6)
    String? rowIdentifier;

    AnalysisPortfolioEventSetConfiguration({this.id,this.analysisId,this.analysisConfigurationId,this.portfolioName,this.modelId,this.rowIdentifier});
    AnalysisPortfolioEventSetConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        analysisId = json['analysisId'];
        analysisConfigurationId = json['analysisConfigurationId'];
        portfolioName = json['portfolioName'];
        modelId = json['modelId'];
        rowIdentifier = json['rowIdentifier'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'analysisId': analysisId,
        'analysisConfigurationId': analysisConfigurationId,
        'portfolioName': portfolioName,
        'modelId': modelId,
        'rowIdentifier': rowIdentifier
    };

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

// @DataContract
class AnalysisConfiguration implements IObjectWithId, IHasAnalysisId, IConvertible
{
    // @DataMember(Order=1)
    int? id;

    // @DataMember(Order=2)
    int? analysisId;

    // @DataMember(Order=3)
    DateTime? windowStartDate;

    // @DataMember(Order=4)
    DateTime? windowEndDate;

    // @DataMember(Order=5)
    bool? standardEnabled;

    // @DataMember(Order=6)
    bool? runOffEnabled;

    // @DataMember(Order=7)
    bool? aggregateEnabled;

    // @DataMember(Order=8)
    bool? occurrenceEnabled;

    // @DataMember(Order=9)
    bool? nettEnabled;

    // @DataMember(Order=10)
    bool? grossEnabled;

    // @DataMember(Order=11)
    double? tailIntensityPercentageStart;

    // @DataMember(Order=12)
    double? tailIntensityPercentageEnd;

    // @DataMember(Order=13)
    int? metaRiskId;

    // @DataMember(Order=14)
    ResultOutputLevel? outputLevel;

    // @DataMember(Order=15)
    ProcessingStatus? processingStatus;

    // @DataMember(Order=16)
    double? eventLossFloorStartRange;

    // @DataMember(Order=17)
    double? eventLossFloorEndRange;

    // @DataMember(Order=18)
    List<AnalysisPortfolioEventSetConfiguration>? analysisPortfolioEventSetConfigurations;

    // @DataMember(Order=19)
    String? rowIdentifier;

    AnalysisConfiguration({this.id,this.analysisId,this.windowStartDate,this.windowEndDate,this.standardEnabled,this.runOffEnabled,this.aggregateEnabled,this.occurrenceEnabled,this.nettEnabled,this.grossEnabled,this.tailIntensityPercentageStart,this.tailIntensityPercentageEnd,this.metaRiskId,this.outputLevel,this.processingStatus,this.eventLossFloorStartRange,this.eventLossFloorEndRange,this.analysisPortfolioEventSetConfigurations,this.rowIdentifier});
    AnalysisConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        analysisId = json['analysisId'];
        windowStartDate = JsonConverters.fromJson(json['windowStartDate'],'DateTime',context!);
        windowEndDate = JsonConverters.fromJson(json['windowEndDate'],'DateTime',context!);
        standardEnabled = json['standardEnabled'];
        runOffEnabled = json['runOffEnabled'];
        aggregateEnabled = json['aggregateEnabled'];
        occurrenceEnabled = json['occurrenceEnabled'];
        nettEnabled = json['nettEnabled'];
        grossEnabled = json['grossEnabled'];
        tailIntensityPercentageStart = JsonConverters.toDouble(json['tailIntensityPercentageStart']);
        tailIntensityPercentageEnd = JsonConverters.toDouble(json['tailIntensityPercentageEnd']);
        metaRiskId = json['metaRiskId'];
        outputLevel = JsonConverters.fromJson(json['outputLevel'],'ResultOutputLevel',context!);
        processingStatus = JsonConverters.fromJson(json['processingStatus'],'ProcessingStatus',context!);
        eventLossFloorStartRange = JsonConverters.toDouble(json['eventLossFloorStartRange']);
        eventLossFloorEndRange = JsonConverters.toDouble(json['eventLossFloorEndRange']);
        analysisPortfolioEventSetConfigurations = JsonConverters.fromJson(json['analysisPortfolioEventSetConfigurations'],'List<AnalysisPortfolioEventSetConfiguration>',context!);
        rowIdentifier = json['rowIdentifier'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'analysisId': analysisId,
        'windowStartDate': JsonConverters.toJson(windowStartDate,'DateTime',context!),
        'windowEndDate': JsonConverters.toJson(windowEndDate,'DateTime',context!),
        'standardEnabled': standardEnabled,
        'runOffEnabled': runOffEnabled,
        'aggregateEnabled': aggregateEnabled,
        'occurrenceEnabled': occurrenceEnabled,
        'nettEnabled': nettEnabled,
        'grossEnabled': grossEnabled,
        'tailIntensityPercentageStart': tailIntensityPercentageStart,
        'tailIntensityPercentageEnd': tailIntensityPercentageEnd,
        'metaRiskId': metaRiskId,
        'outputLevel': JsonConverters.toJson(outputLevel,'ResultOutputLevel',context!),
        'processingStatus': JsonConverters.toJson(processingStatus,'ProcessingStatus',context!),
        'eventLossFloorStartRange': eventLossFloorStartRange,
        'eventLossFloorEndRange': eventLossFloorEndRange,
        'analysisPortfolioEventSetConfigurations': JsonConverters.toJson(analysisPortfolioEventSetConfigurations,'List<AnalysisPortfolioEventSetConfiguration>',context!),
        'rowIdentifier': rowIdentifier
    };

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

enum TransactionType
{
    NotSet,
    S,
    B,
}

// @DataContract
class AnalysisPortfolioAllocation implements IObjectWithId, IConvertible
{
    // @DataMember(Order=1)
    int? id;

    // @DataMember(Order=2)
    int? analysisDealId;

    // @DataMember(Order=3)
    // @Validate(Validator="NotEmpty", Message="PortfolioName is mandatory")
    String? portfolioName;

    // @DataMember(Order=4)
    double? allocationPercentage;

    // @DataMember(Order=5)
    String? rowIdentifier;

    AnalysisPortfolioAllocation({this.id,this.analysisDealId,this.portfolioName,this.allocationPercentage,this.rowIdentifier});
    AnalysisPortfolioAllocation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        analysisDealId = json['analysisDealId'];
        portfolioName = json['portfolioName'];
        allocationPercentage = JsonConverters.toDouble(json['allocationPercentage']);
        rowIdentifier = json['rowIdentifier'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'analysisDealId': analysisDealId,
        'portfolioName': portfolioName,
        'allocationPercentage': allocationPercentage,
        'rowIdentifier': rowIdentifier
    };

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

// @DataContract
class AnalysisDeal implements IObjectWithId, IHasAnalysisId, IConvertible
{
    // @DataMember(Order=1)
    int? id;

    // @DataMember(Order=2)
    int? analysisId;

    // @DataMember(Order=3)
    String? sourceDealId;

    // @DataMember(Order=4)
    String? dealRef;

    // @DataMember(Order=5)
    String? sourceDealSystem;

    // @DataMember(Order=6)
    int? eventSetId;

    // @DataMember(Order=7)
    double? rol;

    // @DataMember(Order=8)
    double? limit;

    // @DataMember(Order=9)
    DateTime? inceptionDate;

    // @DataMember(Order=10)
    DateTime? expiryDate;

    // @DataMember(Order=11)
    TransactionType? transactionType;

    // @DataMember(Order=12)
    List<AnalysisPortfolioAllocation>? allocations;

    // @DataMember(Order=13)
    int? perspectiveIdOverride;

    // @DataMember(Order=14)
    int? eventSetIdOverride;

    // @DataMember(Order=15)
    DateTime? modelAsOfDateOverride;

    // @DataMember(Order=16)
    String? sourceModelSystemOverride;

    // @DataMember(Order=17)
    String? sourceModelIdOverride;

    // @DataMember(Order=18)
    String? sourceEventSetIdOverride;

    // @DataMember(Order=19)
    String? eventSourceSystemOverride;

    // @DataMember(Order=20)
    String? rowIdentifier;

    AnalysisDeal({this.id,this.analysisId,this.sourceDealId,this.dealRef,this.sourceDealSystem,this.eventSetId,this.rol,this.limit,this.inceptionDate,this.expiryDate,this.transactionType,this.allocations,this.perspectiveIdOverride,this.eventSetIdOverride,this.modelAsOfDateOverride,this.sourceModelSystemOverride,this.sourceModelIdOverride,this.sourceEventSetIdOverride,this.eventSourceSystemOverride,this.rowIdentifier});
    AnalysisDeal.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        analysisId = json['analysisId'];
        sourceDealId = json['sourceDealId'];
        dealRef = json['dealRef'];
        sourceDealSystem = json['sourceDealSystem'];
        eventSetId = json['eventSetId'];
        rol = JsonConverters.toDouble(json['rol']);
        limit = JsonConverters.toDouble(json['limit']);
        inceptionDate = JsonConverters.fromJson(json['inceptionDate'],'DateTime',context!);
        expiryDate = JsonConverters.fromJson(json['expiryDate'],'DateTime',context!);
        transactionType = JsonConverters.fromJson(json['transactionType'],'TransactionType',context!);
        allocations = JsonConverters.fromJson(json['allocations'],'List<AnalysisPortfolioAllocation>',context!);
        perspectiveIdOverride = json['perspectiveIdOverride'];
        eventSetIdOverride = json['eventSetIdOverride'];
        modelAsOfDateOverride = JsonConverters.fromJson(json['modelAsOfDateOverride'],'DateTime',context!);
        sourceModelSystemOverride = json['sourceModelSystemOverride'];
        sourceModelIdOverride = json['sourceModelIdOverride'];
        sourceEventSetIdOverride = json['sourceEventSetIdOverride'];
        eventSourceSystemOverride = json['eventSourceSystemOverride'];
        rowIdentifier = json['rowIdentifier'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'analysisId': analysisId,
        'sourceDealId': sourceDealId,
        'dealRef': dealRef,
        'sourceDealSystem': sourceDealSystem,
        'eventSetId': eventSetId,
        'rol': rol,
        'limit': limit,
        'inceptionDate': JsonConverters.toJson(inceptionDate,'DateTime',context!),
        'expiryDate': JsonConverters.toJson(expiryDate,'DateTime',context!),
        'transactionType': JsonConverters.toJson(transactionType,'TransactionType',context!),
        'allocations': JsonConverters.toJson(allocations,'List<AnalysisPortfolioAllocation>',context!),
        'perspectiveIdOverride': perspectiveIdOverride,
        'eventSetIdOverride': eventSetIdOverride,
        'modelAsOfDateOverride': JsonConverters.toJson(modelAsOfDateOverride,'DateTime',context!),
        'sourceModelSystemOverride': sourceModelSystemOverride,
        'sourceModelIdOverride': sourceModelIdOverride,
        'sourceEventSetIdOverride': sourceEventSetIdOverride,
        'eventSourceSystemOverride': eventSourceSystemOverride,
        'rowIdentifier': rowIdentifier
    };

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

// @DataContract
class AnalysisEventIdFilter implements IObjectWithId, IHasAnalysisId, IConvertible
{
    // @DataMember(Order=1)
    int? id;

    // @DataMember(Order=2)
    int? analysisId;

    // @DataMember(Order=3)
    int? eventSourceId;

    // @DataMember(Order=4)
    int? eventId;

    // @DataMember(Order=5)
    String? rowIdentifier;

    AnalysisEventIdFilter({this.id,this.analysisId,this.eventSourceId,this.eventId,this.rowIdentifier});
    AnalysisEventIdFilter.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        analysisId = json['analysisId'];
        eventSourceId = json['eventSourceId'];
        eventId = json['eventId'];
        rowIdentifier = json['rowIdentifier'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'analysisId': analysisId,
        'eventSourceId': eventSourceId,
        'eventId': eventId,
        'rowIdentifier': rowIdentifier
    };

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

enum MessageType
{
    NotSet,
    Persistence,
    Archival,
}

// @DataContract
class MessageTracking implements IConvertible
{
    // @DataMember(Order=1)
    String? id;

    // @DataMember(Order=2)
    int? analysisId;

    // @DataMember(Order=3)
    ProcessingStatus? processingStatus;

    // @DataMember(Order=4)
    MessageType? messageType;

    // @DataMember(Order=5)
    DateTime? createdDateUtc;

    // @DataMember(Order=6)
    DateTime? updatedDateUtc;

    MessageTracking({this.id,this.analysisId,this.processingStatus,this.messageType,this.createdDateUtc,this.updatedDateUtc});
    MessageTracking.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        analysisId = json['analysisId'];
        processingStatus = JsonConverters.fromJson(json['processingStatus'],'ProcessingStatus',context!);
        messageType = JsonConverters.fromJson(json['messageType'],'MessageType',context!);
        createdDateUtc = JsonConverters.fromJson(json['createdDateUtc'],'DateTime',context!);
        updatedDateUtc = JsonConverters.fromJson(json['updatedDateUtc'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'analysisId': analysisId,
        'processingStatus': JsonConverters.toJson(processingStatus,'ProcessingStatus',context!),
        'messageType': JsonConverters.toJson(messageType,'MessageType',context!),
        'createdDateUtc': JsonConverters.toJson(createdDateUtc,'DateTime',context!),
        'updatedDateUtc': JsonConverters.toJson(updatedDateUtc,'DateTime',context!)
    };

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

// @DataContract
class Analysis implements IObjectWithId, IConvertible
{
    // @DataMember(Order=1)
    int? id;

    // @DataMember(Order=2)
    String? name;

    // @DataMember(Order=3)
    DateTime? modelAsOfDate;

    // @DataMember(Order=4)
    int? perspectiveId;

    // @DataMember(Order=5)
    List<AnalysisConfiguration>? configurations;

    // @DataMember(Order=6)
    List<AnalysisDeal>? deals;

    // @DataMember(Order=7)
    List<AnalysisEventIdFilter>? eventIdFilters;

    // @DataMember(Order=8)
    String? createdBy;

    // @DataMember(Order=9)
    DateTime? createdDateUtc;

    // @DataMember(Order=10)
    DateTime? completedDateUtc;

    // @DataMember(Order=11)
    int? legacyAnalysisId;

    // @DataMember(Order=12)
    List<MessageTracking>? resultPersistenceTracking;

    // @DataMember(Order=13)
    ProcessingStatus? processingStatus;

    // @DataMember(Order=14)
    bool? saveResults;

    // @DataMember(Order=15)
    String? eventSourceSystem;

    // @DataMember(Order=16)
    DateTime? updatedDateUtc;

    // @DataMember(Order=17)
    bool? isExpired;

    // @DataMember(Order=18)
    String? rowIdentifier;

    // @DataMember(Order=19)
    String? errorMessage;

    /**
    * Take the minimum simulation count when we have different simulations between event sets
    */
    // @DataMember(Order=20)
    // @ApiMember(DataType="boolean", Description="Take the minimum simulation count when we have different simulations between event sets")
    bool? ignoreSimulationCountMismatch;

    // @DataMember(Order=21)
    // @ignore()
    ProcessingStatus? finalStatus;

    Analysis({this.id,this.name,this.modelAsOfDate,this.perspectiveId,this.configurations,this.deals,this.eventIdFilters,this.createdBy,this.createdDateUtc,this.completedDateUtc,this.legacyAnalysisId,this.resultPersistenceTracking,this.processingStatus,this.saveResults,this.eventSourceSystem,this.updatedDateUtc,this.isExpired,this.rowIdentifier,this.errorMessage,this.ignoreSimulationCountMismatch,this.finalStatus});
    Analysis.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        modelAsOfDate = JsonConverters.fromJson(json['modelAsOfDate'],'DateTime',context!);
        perspectiveId = json['perspectiveId'];
        configurations = JsonConverters.fromJson(json['configurations'],'List<AnalysisConfiguration>',context!);
        deals = JsonConverters.fromJson(json['deals'],'List<AnalysisDeal>',context!);
        eventIdFilters = JsonConverters.fromJson(json['eventIdFilters'],'List<AnalysisEventIdFilter>',context!);
        createdBy = json['createdBy'];
        createdDateUtc = JsonConverters.fromJson(json['createdDateUtc'],'DateTime',context!);
        completedDateUtc = JsonConverters.fromJson(json['completedDateUtc'],'DateTime',context!);
        legacyAnalysisId = json['legacyAnalysisId'];
        resultPersistenceTracking = JsonConverters.fromJson(json['resultPersistenceTracking'],'List<MessageTracking>',context!);
        processingStatus = JsonConverters.fromJson(json['processingStatus'],'ProcessingStatus',context!);
        saveResults = json['saveResults'];
        eventSourceSystem = json['eventSourceSystem'];
        updatedDateUtc = JsonConverters.fromJson(json['updatedDateUtc'],'DateTime',context!);
        isExpired = json['isExpired'];
        rowIdentifier = json['rowIdentifier'];
        errorMessage = json['errorMessage'];
        ignoreSimulationCountMismatch = json['ignoreSimulationCountMismatch'];
        finalStatus = JsonConverters.fromJson(json['finalStatus'],'ProcessingStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'modelAsOfDate': JsonConverters.toJson(modelAsOfDate,'DateTime',context!),
        'perspectiveId': perspectiveId,
        'configurations': JsonConverters.toJson(configurations,'List<AnalysisConfiguration>',context!),
        'deals': JsonConverters.toJson(deals,'List<AnalysisDeal>',context!),
        'eventIdFilters': JsonConverters.toJson(eventIdFilters,'List<AnalysisEventIdFilter>',context!),
        'createdBy': createdBy,
        'createdDateUtc': JsonConverters.toJson(createdDateUtc,'DateTime',context!),
        'completedDateUtc': JsonConverters.toJson(completedDateUtc,'DateTime',context!),
        'legacyAnalysisId': legacyAnalysisId,
        'resultPersistenceTracking': JsonConverters.toJson(resultPersistenceTracking,'List<MessageTracking>',context!),
        'processingStatus': JsonConverters.toJson(processingStatus,'ProcessingStatus',context!),
        'saveResults': saveResults,
        'eventSourceSystem': eventSourceSystem,
        'updatedDateUtc': JsonConverters.toJson(updatedDateUtc,'DateTime',context!),
        'isExpired': isExpired,
        'rowIdentifier': rowIdentifier,
        'errorMessage': errorMessage,
        'ignoreSimulationCountMismatch': ignoreSimulationCountMismatch,
        'finalStatus': JsonConverters.toJson(finalStatus,'ProcessingStatus',context!)
    };

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

abstract class IObjectWithId
{
    int? id;
    String? rowIdentifier;
}

abstract class IHasAnalysisId
{
    int? analysisId;
}

// @Route("/riskstore/analysis", "GET")
class FindAnalysisRequest extends QueryDb<Analysis> implements IReturn<QueryResponse<Analysis>>, IConvertible, IGet
{
    /**
    * The Ids of the Analyses
    */
    // @ApiMember(DataType="integer", Description="The Ids of the Analyses", Format="int64")
    List<int>? ids;

    /**
    * The partial name of the analyses
    */
    // @ApiMember(DataType="string", Description="The partial name of the analyses")
    String? name;

    /**
    * Filter only Standard analysis type
    */
    // @ApiMember(DataType="boolean", Description="Filter only Standard analysis type")
    bool? standardEnabled;

    /**
    * Filter only Run Off analysis type
    */
    // @ApiMember(DataType="boolean", Description="Filter only Run Off analysis type")
    bool? runOffEnabled;

    /**
    * The perspective id used for the analysis
    */
    // @ApiMember(DataType="integer", Description="The perspective id used for the analysis", Format="int32")
    int? perspectiveId;

    /**
    * The partial name of the user who run the analysis
    */
    // @ApiMember(DataType="string", Description="The partial name of the user who run the analysis")
    String? createdBy;

    /**
    * The analysis run date to filter from
    */
    // @ApiMember(DataType="string", Description="The analysis run date to filter from", Format="date-time")
    DateTime? analysisRunFromDateTime;

    /**
    * The analysis run date to filter to
    */
    // @ApiMember(DataType="string", Description="The analysis run date to filter to", Format="date-time")
    DateTime? analysisRunToDateTime;

    /**
    * The status of the analysis. 1 = Processing, 10 = Failed, 20 = Successful
    */
    // @ApiMember(DataType="integer", Description="The status of the analysis. 1 = Processing, 10 = Failed, 20 = Successful", Format="int32")
    ProcessingStatus? processingStatus;

    FindAnalysisRequest({this.ids,this.name,this.standardEnabled,this.runOffEnabled,this.perspectiveId,this.createdBy,this.analysisRunFromDateTime,this.analysisRunToDateTime,this.processingStatus});
    FindAnalysisRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        ids = JsonConverters.fromJson(json['ids'],'List<int>',context!);
        name = json['name'];
        standardEnabled = json['standardEnabled'];
        runOffEnabled = json['runOffEnabled'];
        perspectiveId = json['perspectiveId'];
        createdBy = json['createdBy'];
        analysisRunFromDateTime = JsonConverters.fromJson(json['analysisRunFromDateTime'],'DateTime',context!);
        analysisRunToDateTime = JsonConverters.fromJson(json['analysisRunToDateTime'],'DateTime',context!);
        processingStatus = JsonConverters.fromJson(json['processingStatus'],'ProcessingStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'ids': JsonConverters.toJson(ids,'List<int>',context!),
        'name': name,
        'standardEnabled': standardEnabled,
        'runOffEnabled': runOffEnabled,
        'perspectiveId': perspectiveId,
        'createdBy': createdBy,
        'analysisRunFromDateTime': JsonConverters.toJson(analysisRunFromDateTime,'DateTime',context!),
        'analysisRunToDateTime': JsonConverters.toJson(analysisRunToDateTime,'DateTime',context!),
        'processingStatus': JsonConverters.toJson(processingStatus,'ProcessingStatus',context!)
    });

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

TypeContext _ctx = TypeContext(library: 'riskstoreng_dev.nephila.com', types: <String, TypeInfo> {
    'ProcessingStatus': TypeInfo(TypeOf.Enum, enumValues:ProcessingStatus.values),
    'ResultOutputLevel': TypeInfo(TypeOf.Enum, enumValues:ResultOutputLevel.values),
    'AnalysisPortfolioEventSetConfiguration': TypeInfo(TypeOf.Class, create:() => AnalysisPortfolioEventSetConfiguration()),
    'AnalysisConfiguration': TypeInfo(TypeOf.Class, create:() => AnalysisConfiguration()),
    'List<AnalysisPortfolioEventSetConfiguration>': TypeInfo(TypeOf.Class, create:() => <AnalysisPortfolioEventSetConfiguration>[]),
    'TransactionType': TypeInfo(TypeOf.Enum, enumValues:TransactionType.values),
    'AnalysisPortfolioAllocation': TypeInfo(TypeOf.Class, create:() => AnalysisPortfolioAllocation()),
    'AnalysisDeal': TypeInfo(TypeOf.Class, create:() => AnalysisDeal()),
    'List<AnalysisPortfolioAllocation>': TypeInfo(TypeOf.Class, create:() => <AnalysisPortfolioAllocation>[]),
    'AnalysisEventIdFilter': TypeInfo(TypeOf.Class, create:() => AnalysisEventIdFilter()),
    'MessageType': TypeInfo(TypeOf.Enum, enumValues:MessageType.values),
    'MessageTracking': TypeInfo(TypeOf.Class, create:() => MessageTracking()),
    'Analysis': TypeInfo(TypeOf.Class, create:() => Analysis()),
    'List<AnalysisConfiguration>': TypeInfo(TypeOf.Class, create:() => <AnalysisConfiguration>[]),
    'List<AnalysisDeal>': TypeInfo(TypeOf.Class, create:() => <AnalysisDeal>[]),
    'List<AnalysisEventIdFilter>': TypeInfo(TypeOf.Class, create:() => <AnalysisEventIdFilter>[]),
    'List<MessageTracking>': TypeInfo(TypeOf.Class, create:() => <MessageTracking>[]),
    'IObjectWithId': TypeInfo(TypeOf.Interface),
    'IHasAnalysisId': TypeInfo(TypeOf.Interface),
    'QueryResponse<Analysis>': TypeInfo(TypeOf.Class, create:() => QueryResponse<Analysis>()),
    'FindAnalysisRequest': TypeInfo(TypeOf.Class, create:() => FindAnalysisRequest()),
    'List<Analysis>': TypeInfo(TypeOf.Class, create:() => <Analysis>[]),
});