/* Options:
Date: 2025-09-10 19:51:54
Version: 8.30
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://dev-optimization.power.dev

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

import 'package:servicestack/servicestack.dart';

enum DataProvider
{
    Undefined,
    SPP,
    ERCOT,
    MISO,
    CAISO,
    PJM,
    ISONE,
    NYISO,
    NW,
    SW,
    SE,
    AESO,
    IESO,
    CENACE,
    NONISO,
    EIA,
    PNM,
    NREL,
    NOAA,
    ENTSOE,
    EPIAS,
    SELF,
}

enum PowerPlantType
{
    Undefined,
    Solar,
    Wind,
    Hybrid,
}

class BatteryScenarioKeyGroup implements IConvertible
{
    int? keyId;
    int? year;
    int? nodeId;
    DataProvider? provider;
    int? zoneId;
    PowerPlantType? plantType;
    int? solarId;
    int? windId;
    bool? isServerless;

    BatteryScenarioKeyGroup({this.keyId,this.year,this.nodeId,this.provider,this.zoneId,this.plantType,this.solarId,this.windId,this.isServerless});
    BatteryScenarioKeyGroup.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        keyId = json['keyId'];
        year = json['year'];
        nodeId = json['nodeId'];
        provider = JsonConverters.fromJson(json['provider'],'DataProvider',context!);
        zoneId = json['zoneId'];
        plantType = JsonConverters.fromJson(json['plantType'],'PowerPlantType',context!);
        solarId = json['solarId'];
        windId = json['windId'];
        isServerless = json['isServerless'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'keyId': keyId,
        'year': year,
        'nodeId': nodeId,
        'provider': JsonConverters.toJson(provider,'DataProvider',context!),
        'zoneId': zoneId,
        'plantType': JsonConverters.toJson(plantType,'PowerPlantType',context!),
        'solarId': solarId,
        'windId': windId,
        'isServerless': isServerless
    };

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

enum BatteryScenarioType
{
    Undefined,
    Optimization,
    Sum,
    OptiSum,
    FullTod,
    CapacityTod,
}

enum PriceMarketType
{
    Undefined,
    Realtime,
    DayAhead,
    DART,
}

class BatteryScenarioKeyItem implements IConvertible
{
    String? projectId;
    int? keyId;
    BatteryScenarioType? keyType;
    String? recordKey;
    int? jobStatus;
    int? status;
    DateTime? minDate;
    DateTime? maxDate;
    int? year;
    int? yoyStatus;
    double? usableCapacity;
    double? usableCapacityFactor;
    double? solarUsableCapacity;
    double? solarUsableCapacityFactor;
    PriceMarketType? baseMarket;
    double? baseCapacityRate;
    double? capacityRate;
    double? solarCapacityRate;
    double? windCapacityRate;
    double? chargeEfficinecy;
    double? dischargeEfficinecy;
    int? nodeId;
    DataProvider? provider;
    int? zoneId;
    int? lmpFileId;
    int? productionFileId;
    int? loadFileId;
    int? capacityFileId;
    PowerPlantType? plantType;
    int? solarId;
    int? windId;
    double? ancillaryIncrementFactor;
    double? energyIncrementFactor;
    double? capacityIncrementFactor;

    BatteryScenarioKeyItem({this.projectId,this.keyId,this.keyType,this.recordKey,this.jobStatus,this.status,this.minDate,this.maxDate,this.year,this.yoyStatus,this.usableCapacity,this.usableCapacityFactor,this.solarUsableCapacity,this.solarUsableCapacityFactor,this.baseMarket,this.baseCapacityRate,this.capacityRate,this.solarCapacityRate,this.windCapacityRate,this.chargeEfficinecy,this.dischargeEfficinecy,this.nodeId,this.provider,this.zoneId,this.lmpFileId,this.productionFileId,this.loadFileId,this.capacityFileId,this.plantType,this.solarId,this.windId,this.ancillaryIncrementFactor,this.energyIncrementFactor,this.capacityIncrementFactor});
    BatteryScenarioKeyItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        projectId = json['projectId'];
        keyId = json['keyId'];
        keyType = JsonConverters.fromJson(json['keyType'],'BatteryScenarioType',context!);
        recordKey = json['recordKey'];
        jobStatus = json['jobStatus'];
        status = json['status'];
        minDate = JsonConverters.fromJson(json['minDate'],'DateTime',context!);
        maxDate = JsonConverters.fromJson(json['maxDate'],'DateTime',context!);
        year = json['year'];
        yoyStatus = json['yoyStatus'];
        usableCapacity = JsonConverters.toDouble(json['usableCapacity']);
        usableCapacityFactor = JsonConverters.toDouble(json['usableCapacityFactor']);
        solarUsableCapacity = JsonConverters.toDouble(json['solarUsableCapacity']);
        solarUsableCapacityFactor = JsonConverters.toDouble(json['solarUsableCapacityFactor']);
        baseMarket = JsonConverters.fromJson(json['baseMarket'],'PriceMarketType',context!);
        baseCapacityRate = JsonConverters.toDouble(json['baseCapacityRate']);
        capacityRate = JsonConverters.toDouble(json['capacityRate']);
        solarCapacityRate = JsonConverters.toDouble(json['solarCapacityRate']);
        windCapacityRate = JsonConverters.toDouble(json['windCapacityRate']);
        chargeEfficinecy = JsonConverters.toDouble(json['chargeEfficinecy']);
        dischargeEfficinecy = JsonConverters.toDouble(json['dischargeEfficinecy']);
        nodeId = json['nodeId'];
        provider = JsonConverters.fromJson(json['provider'],'DataProvider',context!);
        zoneId = json['zoneId'];
        lmpFileId = json['lmpFileId'];
        productionFileId = json['productionFileId'];
        loadFileId = json['loadFileId'];
        capacityFileId = json['capacityFileId'];
        plantType = JsonConverters.fromJson(json['plantType'],'PowerPlantType',context!);
        solarId = json['solarId'];
        windId = json['windId'];
        ancillaryIncrementFactor = JsonConverters.toDouble(json['ancillaryIncrementFactor']);
        energyIncrementFactor = JsonConverters.toDouble(json['energyIncrementFactor']);
        capacityIncrementFactor = JsonConverters.toDouble(json['capacityIncrementFactor']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'projectId': projectId,
        'keyId': keyId,
        'keyType': JsonConverters.toJson(keyType,'BatteryScenarioType',context!),
        'recordKey': recordKey,
        'jobStatus': jobStatus,
        'status': status,
        'minDate': JsonConverters.toJson(minDate,'DateTime',context!),
        'maxDate': JsonConverters.toJson(maxDate,'DateTime',context!),
        'year': year,
        'yoyStatus': yoyStatus,
        'usableCapacity': usableCapacity,
        'usableCapacityFactor': usableCapacityFactor,
        'solarUsableCapacity': solarUsableCapacity,
        'solarUsableCapacityFactor': solarUsableCapacityFactor,
        'baseMarket': JsonConverters.toJson(baseMarket,'PriceMarketType',context!),
        'baseCapacityRate': baseCapacityRate,
        'capacityRate': capacityRate,
        'solarCapacityRate': solarCapacityRate,
        'windCapacityRate': windCapacityRate,
        'chargeEfficinecy': chargeEfficinecy,
        'dischargeEfficinecy': dischargeEfficinecy,
        'nodeId': nodeId,
        'provider': JsonConverters.toJson(provider,'DataProvider',context!),
        'zoneId': zoneId,
        'lmpFileId': lmpFileId,
        'productionFileId': productionFileId,
        'loadFileId': loadFileId,
        'capacityFileId': capacityFileId,
        'plantType': JsonConverters.toJson(plantType,'PowerPlantType',context!),
        'solarId': solarId,
        'windId': windId,
        'ancillaryIncrementFactor': ancillaryIncrementFactor,
        'energyIncrementFactor': energyIncrementFactor,
        'capacityIncrementFactor': capacityIncrementFactor
    };

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

enum BatteryProjectGroup
{
    Undefined,
    StandAlone,
    FTM,
    BTM,
}

enum BooleanValue
{
    Undefined,
    Yes,
    No,
    Custom,
}

class BatteryProjectTodItem implements IConvertible
{
    int? month;
    int? weekDay;
    int? hour;
    double? price;
    // @ignore()
    String? id;

    BatteryProjectTodItem({this.month,this.weekDay,this.hour,this.price,this.id});
    BatteryProjectTodItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        month = json['month'];
        weekDay = json['weekDay'];
        hour = json['hour'];
        price = JsonConverters.toDouble(json['price']);
        id = json['id'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'month': month,
        'weekDay': weekDay,
        'hour': hour,
        'price': price,
        'id': id
    };

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

enum RevenueStackingMode
{
    SolveWithoutAncillary,
    SolveWithAncillary,
}

class MonthlyRequestBase implements IConvertible
{
    String? projectId;
    int? nodeAltId;
    DataProvider? iso;
    BooleanValue? useEnergy;
    BooleanValue? useAncillary;
    bool? useCapacityTod;
    PriceMarketType? baseMarket;
    List<BatteryProjectTodItem>? capacityTODs;
    double? useRegup;
    double? useRegdown;
    double? useSpinning;
    double? useNonSpinning;
    double? paraciticLossesOperation;
    double? paraciticLossesResting;
    double? hvacLosses;
    double? acCablingLosses;
    double? transformatorLosses;
    double? otherLosses;
    int? representativeYear;
    int? incrementReferanceYear;
    int? useFutureData;
    double? maxDailyCycle;
    double? minDailyProfitPerMw;
    int? ancillaryFileId;
    int? lmpFileId;
    double? maxChargingPriceCap;
    double? maxDischargingPriceCap;
    double? maxAncillaryPriceCap;
    RevenueStackingMode? revenueStackingMode;
    int? optimizationQuality;
    int? ensureExlusive;
    int? nodeRefId;
    bool? useInternalSolver;

    MonthlyRequestBase({this.projectId,this.nodeAltId,this.iso,this.useEnergy,this.useAncillary,this.useCapacityTod,this.baseMarket,this.capacityTODs,this.useRegup,this.useRegdown,this.useSpinning,this.useNonSpinning,this.paraciticLossesOperation,this.paraciticLossesResting,this.hvacLosses,this.acCablingLosses,this.transformatorLosses,this.otherLosses,this.representativeYear,this.incrementReferanceYear,this.useFutureData,this.maxDailyCycle,this.minDailyProfitPerMw,this.ancillaryFileId,this.lmpFileId,this.maxChargingPriceCap,this.maxDischargingPriceCap,this.maxAncillaryPriceCap,this.revenueStackingMode,this.optimizationQuality,this.ensureExlusive,this.nodeRefId,this.useInternalSolver});
    MonthlyRequestBase.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        projectId = json['projectId'];
        nodeAltId = json['nodeAltId'];
        iso = JsonConverters.fromJson(json['iso'],'DataProvider',context!);
        useEnergy = JsonConverters.fromJson(json['useEnergy'],'BooleanValue',context!);
        useAncillary = JsonConverters.fromJson(json['useAncillary'],'BooleanValue',context!);
        useCapacityTod = json['useCapacityTod'];
        baseMarket = JsonConverters.fromJson(json['baseMarket'],'PriceMarketType',context!);
        capacityTODs = JsonConverters.fromJson(json['capacityTODs'],'List<BatteryProjectTodItem>',context!);
        useRegup = JsonConverters.toDouble(json['useRegup']);
        useRegdown = JsonConverters.toDouble(json['useRegdown']);
        useSpinning = JsonConverters.toDouble(json['useSpinning']);
        useNonSpinning = JsonConverters.toDouble(json['useNonSpinning']);
        paraciticLossesOperation = JsonConverters.toDouble(json['paraciticLossesOperation']);
        paraciticLossesResting = JsonConverters.toDouble(json['paraciticLossesResting']);
        hvacLosses = JsonConverters.toDouble(json['hvacLosses']);
        acCablingLosses = JsonConverters.toDouble(json['acCablingLosses']);
        transformatorLosses = JsonConverters.toDouble(json['transformatorLosses']);
        otherLosses = JsonConverters.toDouble(json['otherLosses']);
        representativeYear = json['representativeYear'];
        incrementReferanceYear = json['incrementReferanceYear'];
        useFutureData = json['useFutureData'];
        maxDailyCycle = JsonConverters.toDouble(json['maxDailyCycle']);
        minDailyProfitPerMw = JsonConverters.toDouble(json['minDailyProfitPerMw']);
        ancillaryFileId = json['ancillaryFileId'];
        lmpFileId = json['lmpFileId'];
        maxChargingPriceCap = JsonConverters.toDouble(json['maxChargingPriceCap']);
        maxDischargingPriceCap = JsonConverters.toDouble(json['maxDischargingPriceCap']);
        maxAncillaryPriceCap = JsonConverters.toDouble(json['maxAncillaryPriceCap']);
        revenueStackingMode = JsonConverters.fromJson(json['revenueStackingMode'],'RevenueStackingMode',context!);
        optimizationQuality = json['optimizationQuality'];
        ensureExlusive = json['ensureExlusive'];
        nodeRefId = json['nodeRefId'];
        useInternalSolver = json['useInternalSolver'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'projectId': projectId,
        'nodeAltId': nodeAltId,
        'iso': JsonConverters.toJson(iso,'DataProvider',context!),
        'useEnergy': JsonConverters.toJson(useEnergy,'BooleanValue',context!),
        'useAncillary': JsonConverters.toJson(useAncillary,'BooleanValue',context!),
        'useCapacityTod': useCapacityTod,
        'baseMarket': JsonConverters.toJson(baseMarket,'PriceMarketType',context!),
        'capacityTODs': JsonConverters.toJson(capacityTODs,'List<BatteryProjectTodItem>',context!),
        'useRegup': useRegup,
        'useRegdown': useRegdown,
        'useSpinning': useSpinning,
        'useNonSpinning': useNonSpinning,
        'paraciticLossesOperation': paraciticLossesOperation,
        'paraciticLossesResting': paraciticLossesResting,
        'hvacLosses': hvacLosses,
        'acCablingLosses': acCablingLosses,
        'transformatorLosses': transformatorLosses,
        'otherLosses': otherLosses,
        'representativeYear': representativeYear,
        'incrementReferanceYear': incrementReferanceYear,
        'useFutureData': useFutureData,
        'maxDailyCycle': maxDailyCycle,
        'minDailyProfitPerMw': minDailyProfitPerMw,
        'ancillaryFileId': ancillaryFileId,
        'lmpFileId': lmpFileId,
        'maxChargingPriceCap': maxChargingPriceCap,
        'maxDischargingPriceCap': maxDischargingPriceCap,
        'maxAncillaryPriceCap': maxAncillaryPriceCap,
        'revenueStackingMode': JsonConverters.toJson(revenueStackingMode,'RevenueStackingMode',context!),
        'optimizationQuality': optimizationQuality,
        'ensureExlusive': ensureExlusive,
        'nodeRefId': nodeRefId,
        'useInternalSolver': useInternalSolver
    };

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

class YearlyApiStatusResponse implements IConvertible
{
    int? failedCount;
    String? message;

    YearlyApiStatusResponse({this.failedCount,this.message});
    YearlyApiStatusResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        failedCount = json['failedCount'];
        message = json['message'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'failedCount': failedCount,
        'message': message
    };

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

// @Route("/optimizer/yearly", "POST")
class CommonOptimizerYearlyRequest extends MonthlyRequestBase implements IReturn<YearlyApiStatusResponse>, IConvertible, IPost
{
    int? month;
    BatteryScenarioKeyGroup? group;
    BatteryScenarioKeyItem? key;
    BatteryProjectGroup? projectGroup;

    CommonOptimizerYearlyRequest({this.month,this.group,this.key,this.projectGroup});
    CommonOptimizerYearlyRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        month = json['month'];
        group = JsonConverters.fromJson(json['group'],'BatteryScenarioKeyGroup',context!);
        key = JsonConverters.fromJson(json['key'],'BatteryScenarioKeyItem',context!);
        projectGroup = JsonConverters.fromJson(json['projectGroup'],'BatteryProjectGroup',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'month': month,
        'group': JsonConverters.toJson(group,'BatteryScenarioKeyGroup',context!),
        'key': JsonConverters.toJson(key,'BatteryScenarioKeyItem',context!),
        'projectGroup': JsonConverters.toJson(projectGroup,'BatteryProjectGroup',context!)
    });

    createResponse() => YearlyApiStatusResponse();
    getResponseTypeName() => "YearlyApiStatusResponse";
    getTypeName() => "CommonOptimizerYearlyRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'dev_optimization.power.dev', types: <String, TypeInfo> {
    'DataProvider': TypeInfo(TypeOf.Enum, enumValues:DataProvider.values),
    'PowerPlantType': TypeInfo(TypeOf.Enum, enumValues:PowerPlantType.values),
    'BatteryScenarioKeyGroup': TypeInfo(TypeOf.Class, create:() => BatteryScenarioKeyGroup()),
    'BatteryScenarioType': TypeInfo(TypeOf.Enum, enumValues:BatteryScenarioType.values),
    'PriceMarketType': TypeInfo(TypeOf.Enum, enumValues:PriceMarketType.values),
    'BatteryScenarioKeyItem': TypeInfo(TypeOf.Class, create:() => BatteryScenarioKeyItem()),
    'BatteryProjectGroup': TypeInfo(TypeOf.Enum, enumValues:BatteryProjectGroup.values),
    'BooleanValue': TypeInfo(TypeOf.Enum, enumValues:BooleanValue.values),
    'BatteryProjectTodItem': TypeInfo(TypeOf.Class, create:() => BatteryProjectTodItem()),
    'RevenueStackingMode': TypeInfo(TypeOf.Enum, enumValues:RevenueStackingMode.values),
    'MonthlyRequestBase': TypeInfo(TypeOf.Class, create:() => MonthlyRequestBase()),
    'List<BatteryProjectTodItem>': TypeInfo(TypeOf.Class, create:() => <BatteryProjectTodItem>[]),
    'YearlyApiStatusResponse': TypeInfo(TypeOf.Class, create:() => YearlyApiStatusResponse()),
    'CommonOptimizerYearlyRequest': TypeInfo(TypeOf.Class, create:() => CommonOptimizerYearlyRequest()),
});