Nephila RiskStore

<back to all web services

FindAnalysisPortfolioEventSetConfigurations

import 'package:servicestack/servicestack.dart';

// @DataContract
abstract class QueryBase
{
    // @DataMember(Order=1)
    int? skip;

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

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

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

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

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

    // @DataMember(Order=7)
    Map<String,String?>? meta;

    QueryBase({this.skip,this.take,this.orderBy,this.orderByDesc,this.include,this.fields,this.meta});
    QueryBase.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        skip = json['skip'];
        take = json['take'];
        orderBy = json['orderBy'];
        orderByDesc = json['orderByDesc'];
        include = json['include'];
        fields = json['fields'];
        meta = JsonConverters.toStringMap(json['meta']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'skip': skip,
        'take': take,
        'orderBy': orderBy,
        'orderByDesc': orderByDesc,
        'include': include,
        'fields': fields,
        'meta': meta
    };

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

abstract class QueryDb<T> extends QueryBase
{
    QueryDb();
    QueryDb.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() => "QueryDb<$T>";
    TypeContext? context = _ctx;
}

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

class FindAnalysisPortfolioEventSetConfigurations extends QueryDb<AnalysisPortfolioEventSetConfiguration> implements IConvertible
{
    // @ApiMember(DataType="integer", Format="int64")
    List<int>? ids;

    // @ApiMember(DataType="integer", Format="int64")
    int? analysisId;

    // @ApiMember(DataType="integer", Format="int64")
    List<int>? analysisIds;

    // @ApiMember(DataType="integer", Format="int64")
    int? analysisConfigurationId;

    // @ApiMember(DataType="integer", Format="int64")
    List<int>? analysisConfigurationIds;

    // @ApiMember(DataType="string")
    String? portfolioName;

    FindAnalysisPortfolioEventSetConfigurations({this.ids,this.analysisId,this.analysisIds,this.analysisConfigurationId,this.analysisConfigurationIds,this.portfolioName});
    FindAnalysisPortfolioEventSetConfigurations.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        ids = JsonConverters.fromJson(json['ids'],'List<int>',context!);
        analysisId = json['analysisId'];
        analysisIds = JsonConverters.fromJson(json['analysisIds'],'List<int>',context!);
        analysisConfigurationId = json['analysisConfigurationId'];
        analysisConfigurationIds = JsonConverters.fromJson(json['analysisConfigurationIds'],'List<int>',context!);
        portfolioName = json['portfolioName'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'ids': JsonConverters.toJson(ids,'List<int>',context!),
        'analysisId': analysisId,
        'analysisIds': JsonConverters.toJson(analysisIds,'List<int>',context!),
        'analysisConfigurationId': analysisConfigurationId,
        'analysisConfigurationIds': JsonConverters.toJson(analysisConfigurationIds,'List<int>',context!),
        'portfolioName': portfolioName
    });

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

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

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

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

// @DataContract
class QueryResponse<T> implements IConvertible
{
    // @DataMember(Order=1)
    int? offset;

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

    // @DataMember(Order=3)
    List<Analysis>? results;

    // @DataMember(Order=4)
    Map<String,String?>? meta;

    // @DataMember(Order=5)
    ResponseStatus? responseStatus;

    QueryResponse({this.offset,this.total,this.results,this.meta,this.responseStatus});
    QueryResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        offset = json['offset'];
        total = json['total'];
        results = JsonConverters.fromJson(json['results'],'List<Analysis>',context!);
        meta = JsonConverters.toStringMap(json['meta']);
        responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'offset': offset,
        'total': total,
        'results': JsonConverters.toJson(results,'List<Analysis>',context!),
        'meta': meta,
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
    };

    getTypeName() => "QueryResponse<$T>";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'riskstoreng_dev.nephila.com', types: <String, TypeInfo> {
    'AnalysisPortfolioEventSetConfiguration': TypeInfo(TypeOf.Class, create:() => AnalysisPortfolioEventSetConfiguration()),
    'FindAnalysisPortfolioEventSetConfigurations': TypeInfo(TypeOf.Class, create:() => FindAnalysisPortfolioEventSetConfigurations()),
    'List<AnalysisPortfolioEventSetConfiguration>': TypeInfo(TypeOf.Class, create:() => <AnalysisPortfolioEventSetConfiguration>[]),
    'ResultOutputLevel': TypeInfo(TypeOf.Enum, enumValues:ResultOutputLevel.values),
    'ProcessingStatus': TypeInfo(TypeOf.Enum, enumValues:ProcessingStatus.values),
    'AnalysisConfiguration': TypeInfo(TypeOf.Class, create:() => AnalysisConfiguration()),
    '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>[]),
    'List<Analysis>': TypeInfo(TypeOf.Class, create:() => <Analysis>[]),
});

Dart FindAnalysisPortfolioEventSetConfigurations DTOs

GET /api/riskstore/results/portfolio-event-set-configurations HTTP/1.1 
Host: riskstoreng-dev.nephila.com 
Accept: text/csv

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

{"offset":0,"total":0,"results":[{"id":0,"analysisId":0,"analysisConfigurationId":0,"portfolioName":"String","modelId":"String","rowIdentifier":"00000000000000000000000000000000"}],"meta":{"String":"String"},"responseStatus":{"__type":"ServiceStack.ResponseStatus, ServiceStack.Interfaces","errorCode":"String","message":"String","stackTrace":"String","errors":[{"__type":"ServiceStack.ResponseError, ServiceStack.Interfaces","errorCode":"String","fieldName":"String","message":"String","meta":{"String":"String"}}],"meta":{"String":"String"}}}