/* Options:
Date: 2026-06-13 13:37:17
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: GetAnalysisRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

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

enum AnalysisType
{
    NotSet,
    Standard,
    RunOff,
}

enum SimulationLossPerspective
{
    NotSet,
    Agg,
    Occ,
}

enum ReinsurancePremiumLossType
{
    NotSet,
    Net,
    Gross,
}

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

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

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

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

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

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

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

    AnalysisPortfolioEventSetResult({this.id,this.analysisId,this.analysisPortfolioEventSetConfigurationId,this.analysisResultId,this.portfolioName,this.rowIdentifier});
    AnalysisPortfolioEventSetResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

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

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

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

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

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

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

    // @DataMember(Order=7)
    AnalysisType? analysisType;

    // @DataMember(Order=8)
    SimulationLossPerspective? simulationLossPerspective;

    // @DataMember(Order=9)
    ReinsurancePremiumLossType? reinsurancePremiumLossType;

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

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

    // @DataMember(Order=12)
    List<AnalysisPortfolioEventSetResult>? analysisPortfolioEventSetResults;

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

    AnalysisResult({this.id,this.analysisId,this.analysisConfigurationId,this.container,this.blobName,this.resultTableName,this.analysisType,this.simulationLossPerspective,this.reinsurancePremiumLossType,this.outputLevel,this.metaRiskId,this.analysisPortfolioEventSetResults,this.rowIdentifier});
    AnalysisResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        analysisId = json['analysisId'];
        analysisConfigurationId = json['analysisConfigurationId'];
        container = json['container'];
        blobName = json['blobName'];
        resultTableName = json['resultTableName'];
        analysisType = JsonConverters.fromJson(json['analysisType'],'AnalysisType',context!);
        simulationLossPerspective = JsonConverters.fromJson(json['simulationLossPerspective'],'SimulationLossPerspective',context!);
        reinsurancePremiumLossType = JsonConverters.fromJson(json['reinsurancePremiumLossType'],'ReinsurancePremiumLossType',context!);
        outputLevel = JsonConverters.fromJson(json['outputLevel'],'ResultOutputLevel',context!);
        metaRiskId = json['metaRiskId'];
        analysisPortfolioEventSetResults = JsonConverters.fromJson(json['analysisPortfolioEventSetResults'],'List<AnalysisPortfolioEventSetResult>',context!);
        rowIdentifier = json['rowIdentifier'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'analysisId': analysisId,
        'analysisConfigurationId': analysisConfigurationId,
        'container': container,
        'blobName': blobName,
        'resultTableName': resultTableName,
        'analysisType': JsonConverters.toJson(analysisType,'AnalysisType',context!),
        'simulationLossPerspective': JsonConverters.toJson(simulationLossPerspective,'SimulationLossPerspective',context!),
        'reinsurancePremiumLossType': JsonConverters.toJson(reinsurancePremiumLossType,'ReinsurancePremiumLossType',context!),
        'outputLevel': JsonConverters.toJson(outputLevel,'ResultOutputLevel',context!),
        'metaRiskId': metaRiskId,
        'analysisPortfolioEventSetResults': JsonConverters.toJson(analysisPortfolioEventSetResults,'List<AnalysisPortfolioEventSetResult>',context!),
        'rowIdentifier': rowIdentifier
    };

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

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

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

class AnalysisPortfolioMetric implements IHasAnalysisResultId, IConvertible
{
    AnalysisType? analysisType;
    SimulationLossPerspective? simulationLossPerspective;
    ReinsurancePremiumLossType? reinsurancePremiumLossType;
    String? metricDescription;
    String? portfolioName;
    double? metric;
    int? metaRiskId;
    int? simulation;
    int? analysisResultId;

    AnalysisPortfolioMetric({this.analysisType,this.simulationLossPerspective,this.reinsurancePremiumLossType,this.metricDescription,this.portfolioName,this.metric,this.metaRiskId,this.simulation,this.analysisResultId});
    AnalysisPortfolioMetric.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        analysisType = JsonConverters.fromJson(json['analysisType'],'AnalysisType',context!);
        simulationLossPerspective = JsonConverters.fromJson(json['simulationLossPerspective'],'SimulationLossPerspective',context!);
        reinsurancePremiumLossType = JsonConverters.fromJson(json['reinsurancePremiumLossType'],'ReinsurancePremiumLossType',context!);
        metricDescription = json['metricDescription'];
        portfolioName = json['portfolioName'];
        metric = JsonConverters.toDouble(json['metric']);
        metaRiskId = json['metaRiskId'];
        simulation = json['simulation'];
        analysisResultId = json['analysisResultId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'analysisType': JsonConverters.toJson(analysisType,'AnalysisType',context!),
        'simulationLossPerspective': JsonConverters.toJson(simulationLossPerspective,'SimulationLossPerspective',context!),
        'reinsurancePremiumLossType': JsonConverters.toJson(reinsurancePremiumLossType,'ReinsurancePremiumLossType',context!),
        'metricDescription': metricDescription,
        'portfolioName': portfolioName,
        'metric': metric,
        'metaRiskId': metaRiskId,
        'simulation': simulation,
        'analysisResultId': analysisResultId
    };

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

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

abstract class IHasAnalysisResultId
{
    int? analysisResultId;
}

abstract class IHasAnalysisId
{
    int? analysisId;
}

class RollupResponse implements IConvertible
{
    Analysis? analysis;
    List<AnalysisPortfolioMetric>? portfolioMetrics;
    List<AnalysisResult>? results;
    ResponseStatus? responseStatus;
    List<String>? unresolvedDealIds;
    List<ValueTuple<String,String>>? unlinkedDealIds;
    String? message;

    RollupResponse({this.analysis,this.portfolioMetrics,this.results,this.responseStatus,this.unresolvedDealIds,this.unlinkedDealIds,this.message});
    RollupResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        analysis = JsonConverters.fromJson(json['analysis'],'Analysis',context!);
        portfolioMetrics = JsonConverters.fromJson(json['portfolioMetrics'],'List<AnalysisPortfolioMetric>',context!);
        results = JsonConverters.fromJson(json['results'],'List<AnalysisResult>',context!);
        responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
        unresolvedDealIds = JsonConverters.fromJson(json['unresolvedDealIds'],'List<String>',context!);
        unlinkedDealIds = JsonConverters.fromJson(json['unlinkedDealIds'],'List<ValueTuple<String,String>>',context!);
        message = json['message'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'analysis': JsonConverters.toJson(analysis,'Analysis',context!),
        'portfolioMetrics': JsonConverters.toJson(portfolioMetrics,'List<AnalysisPortfolioMetric>',context!),
        'results': JsonConverters.toJson(results,'List<AnalysisResult>',context!),
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!),
        'unresolvedDealIds': JsonConverters.toJson(unresolvedDealIds,'List<String>',context!),
        'unlinkedDealIds': JsonConverters.toJson(unlinkedDealIds,'List<ValueTuple<String,String>>',context!),
        'message': message
    };

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

// @Route("/riskstore/analysis/results", "GET")
class GetAnalysisRequest implements IReturn<RollupResponse>, IGet, IConvertible
{
    /**
    * The analysis id
    */
    // @ApiMember(DataType="integer", Description="The analysis id", Format="int64")
    int? id;

    /**
    * The legacy analysis id
    */
    // @ApiMember(DataType="integer", Description="The legacy analysis id", Format="int64")
    int? legacyId;

    /**
    * True to not load all deal allocations, analysis runs etc...
    */
    // @ApiMember(DataType="boolean", Description="True to not load all deal allocations, analysis runs etc...")
    bool? onlyCoreData;

    GetAnalysisRequest({this.id,this.legacyId,this.onlyCoreData});
    GetAnalysisRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        legacyId = json['legacyId'];
        onlyCoreData = json['onlyCoreData'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'legacyId': legacyId,
        'onlyCoreData': onlyCoreData
    };

    createResponse() => RollupResponse();
    getResponseTypeName() => "RollupResponse";
    getTypeName() => "GetAnalysisRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'riskstoreng_dev.nephila.com', types: <String, TypeInfo> {
    'AnalysisType': TypeInfo(TypeOf.Enum, enumValues:AnalysisType.values),
    'SimulationLossPerspective': TypeInfo(TypeOf.Enum, enumValues:SimulationLossPerspective.values),
    'ReinsurancePremiumLossType': TypeInfo(TypeOf.Enum, enumValues:ReinsurancePremiumLossType.values),
    'ResultOutputLevel': TypeInfo(TypeOf.Enum, enumValues:ResultOutputLevel.values),
    'AnalysisPortfolioEventSetResult': TypeInfo(TypeOf.Class, create:() => AnalysisPortfolioEventSetResult()),
    'AnalysisResult': TypeInfo(TypeOf.Class, create:() => AnalysisResult()),
    'List<AnalysisPortfolioEventSetResult>': TypeInfo(TypeOf.Class, create:() => <AnalysisPortfolioEventSetResult>[]),
    'ProcessingStatus': TypeInfo(TypeOf.Enum, enumValues:ProcessingStatus.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>[]),
    'AnalysisPortfolioMetric': TypeInfo(TypeOf.Class, create:() => AnalysisPortfolioMetric()),
    'IObjectWithId': TypeInfo(TypeOf.Interface),
    'IHasAnalysisResultId': TypeInfo(TypeOf.Interface),
    'IHasAnalysisId': TypeInfo(TypeOf.Interface),
    'RollupResponse': TypeInfo(TypeOf.Class, create:() => RollupResponse()),
    'List<AnalysisPortfolioMetric>': TypeInfo(TypeOf.Class, create:() => <AnalysisPortfolioMetric>[]),
    'List<AnalysisResult>': TypeInfo(TypeOf.Class, create:() => <AnalysisResult>[]),
    'List<ValueTuple<String,String>>': TypeInfo(TypeOf.Class, create:() => <ValueTuple<String,String>>[]),
    'ValueTuple<String,String>': TypeInfo(TypeOf.Class, create:() => ValueTuple<String,String>()),
    'GetAnalysisRequest': TypeInfo(TypeOf.Class, create:() => GetAnalysisRequest()),
});