/* Options:
Date: 2025-09-10 19:24: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: CommonOptimizerRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

class CommonOptimizerPortalRequestBase implements IConvertible
{
    String? projectId;
    bool? isBatchSimulation;
    bool? force;
    bool? disableEBSSpot;
    bool? isServerless;
    String? apiActionId;
    int? nodeId;
    int? parallelProject;
    int? parallelYears;
    int? ensureExlusive;

    CommonOptimizerPortalRequestBase({this.projectId,this.isBatchSimulation,this.force,this.disableEBSSpot,this.isServerless,this.apiActionId,this.nodeId,this.parallelProject,this.parallelYears,this.ensureExlusive});
    CommonOptimizerPortalRequestBase.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        projectId = json['projectId'];
        isBatchSimulation = json['isBatchSimulation'];
        force = json['force'];
        disableEBSSpot = json['disableEBSSpot'];
        isServerless = json['isServerless'];
        apiActionId = json['apiActionId'];
        nodeId = json['nodeId'];
        parallelProject = json['parallelProject'];
        parallelYears = json['parallelYears'];
        ensureExlusive = json['ensureExlusive'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'projectId': projectId,
        'isBatchSimulation': isBatchSimulation,
        'force': force,
        'disableEBSSpot': disableEBSSpot,
        'isServerless': isServerless,
        'apiActionId': apiActionId,
        'nodeId': nodeId,
        'parallelProject': parallelProject,
        'parallelYears': parallelYears,
        'ensureExlusive': ensureExlusive
    };

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

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

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 BooleanValue
{
    Undefined,
    Yes,
    No,
    Custom,
}

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

enum RevenueStackingMode
{
    SolveWithoutAncillary,
    SolveWithAncillary,
}

enum ApiResponseStatus
{
    Undefined,
    Success,
    Pending,
    Failed,
}

enum BatterySimulationType
{
    Undefined,
    SingleRun,
    BatchSimulation,
    BatchSub,
    Siting,
}

enum BatteryProjectAction
{
    Undefined,
    Arbitrage,
    PeakShaving,
    Smooting,
    Firming,
}

enum BatteryDataSoruce
{
    Undefined,
    Merchant,
    Future,
    TOD,
}

enum TimeGranularity
{
    Undefined,
    hourly,
    daily,
    weekly,
    monthy,
    yearly,
    fivemin,
    tenmin,
    fifteenmin,
    halfhour,
    quarterly,
    twohours,
    threehours,
    fourhours,
    sixhours,
    eighthours,
    twelvehours,
    irregular,
}

enum CapacityMethod
{
    Undefined,
    Annual,
    Tod,
    Schedule,
}

enum BatteryProductionDataSource
{
    Undefined,
    SetClosest,
    UploadedFile,
}

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

class BatteryProjectForOptimizer implements IConvertible
{
    String? projectId;
    String? version;
    String? baseId;
    int? altId;
    BatterySimulationType? simulationType;
    BatteryProjectGroup? projectGroup;
    BatteryProjectAction? projectAction;
    DataProvider? iso;
    String? name;
    int? baseNodeId;
    int? orgNodeId;
    int? baseZoneId;
    BatteryDataSoruce? dataSource;
    PriceMarketType? baseMarket;
    TimeGranularity? priceGranularity;
    DateTime? startDate;
    DateTime? endDate;
    double? batteryCapacity;
    double? interconnectionLimit;
    double? namepaletCapacity;
    // @ignore()
    double? chargeDischargeLimit;

    // @ignore()
    double? baseCapacityRate;

    // @ignore()
    double? capacityRate;

    double? chargeEfficiency;
    double? disChargeEfficiency;
    double? paraciticLossesOperation;
    double? paraciticLossesResting;
    double? hvacLosses;
    double? acCablingLosses;
    double? transformatorLosses;
    double? thermalLosses;
    double? otherLosses;
    BooleanValue? useEnergy;
    BooleanValue? useCapacity;
    CapacityMethod? capacityBasis;
    double? capacityPayment;
    double? netCapacityFactor;
    BooleanValue? useAncillary;
    BatteryProductionDataSource? productionDataSource;
    PowerPlantType? powerPlantType;
    double? solarAcCapacity;
    double? solarDcCapacity;
    double? windAcCapacity;
    // @ignore()
    double? solarCapacityRate;

    // @ignore()
    double? windCapacityRate;

    int? status;
    int? simulationStatus;
    DateTime? lastSimulationDate;
    DateTime? dataStartDate;
    DateTime? dataEndDate;
    int? solarId;
    int? windId;
    int? lmpFileId;
    int? productionFileId;
    int? loadFileId;
    int? capacityFileId;
    int? nodeAltId;
    int? nodeRefId;
    double? useRegup;
    double? useRegdown;
    double? useSpinning;
    double? useNonSpinning;
    double? solarDegredation;
    double? batteryDegredation;
    double? augmentation;
    double? augmentationFrequency;
    double? energyIncrement;
    double? ancillaryIncrement;
    int? enableGridArbitrage;
    int? incrementReferanceYear;
    int? representativeYear;
    int? useFutureData;
    double? maxDailyCycle;
    double? minDailyProfitPerMw;
    int? ancillaryFileId;
    double? maxChargingPriceCap;
    double? maxDischargingPriceCap;
    double? maxAncillaryPriceCap;
    RevenueStackingMode? revenueStackingMode;
    int? optimizationQuality;
    bool? useInternalSolver;

    BatteryProjectForOptimizer({this.projectId,this.version,this.baseId,this.altId,this.simulationType,this.projectGroup,this.projectAction,this.iso,this.name,this.baseNodeId,this.orgNodeId,this.baseZoneId,this.dataSource,this.baseMarket,this.priceGranularity,this.startDate,this.endDate,this.batteryCapacity,this.interconnectionLimit,this.namepaletCapacity,this.chargeDischargeLimit,this.baseCapacityRate,this.capacityRate,this.chargeEfficiency,this.disChargeEfficiency,this.paraciticLossesOperation,this.paraciticLossesResting,this.hvacLosses,this.acCablingLosses,this.transformatorLosses,this.thermalLosses,this.otherLosses,this.useEnergy,this.useCapacity,this.capacityBasis,this.capacityPayment,this.netCapacityFactor,this.useAncillary,this.productionDataSource,this.powerPlantType,this.solarAcCapacity,this.solarDcCapacity,this.windAcCapacity,this.solarCapacityRate,this.windCapacityRate,this.status,this.simulationStatus,this.lastSimulationDate,this.dataStartDate,this.dataEndDate,this.solarId,this.windId,this.lmpFileId,this.productionFileId,this.loadFileId,this.capacityFileId,this.nodeAltId,this.nodeRefId,this.useRegup,this.useRegdown,this.useSpinning,this.useNonSpinning,this.solarDegredation,this.batteryDegredation,this.augmentation,this.augmentationFrequency,this.energyIncrement,this.ancillaryIncrement,this.enableGridArbitrage,this.incrementReferanceYear,this.representativeYear,this.useFutureData,this.maxDailyCycle,this.minDailyProfitPerMw,this.ancillaryFileId,this.maxChargingPriceCap,this.maxDischargingPriceCap,this.maxAncillaryPriceCap,this.revenueStackingMode,this.optimizationQuality,this.useInternalSolver});
    BatteryProjectForOptimizer.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        projectId = json['projectId'];
        version = json['version'];
        baseId = json['baseId'];
        altId = json['altId'];
        simulationType = JsonConverters.fromJson(json['simulationType'],'BatterySimulationType',context!);
        projectGroup = JsonConverters.fromJson(json['projectGroup'],'BatteryProjectGroup',context!);
        projectAction = JsonConverters.fromJson(json['projectAction'],'BatteryProjectAction',context!);
        iso = JsonConverters.fromJson(json['iso'],'DataProvider',context!);
        name = json['name'];
        baseNodeId = json['baseNodeId'];
        orgNodeId = json['orgNodeId'];
        baseZoneId = json['baseZoneId'];
        dataSource = JsonConverters.fromJson(json['dataSource'],'BatteryDataSoruce',context!);
        baseMarket = JsonConverters.fromJson(json['baseMarket'],'PriceMarketType',context!);
        priceGranularity = JsonConverters.fromJson(json['priceGranularity'],'TimeGranularity',context!);
        startDate = JsonConverters.fromJson(json['startDate'],'DateTime',context!);
        endDate = JsonConverters.fromJson(json['endDate'],'DateTime',context!);
        batteryCapacity = JsonConverters.toDouble(json['batteryCapacity']);
        interconnectionLimit = JsonConverters.toDouble(json['interconnectionLimit']);
        namepaletCapacity = JsonConverters.toDouble(json['namepaletCapacity']);
        chargeDischargeLimit = JsonConverters.toDouble(json['chargeDischargeLimit']);
        baseCapacityRate = JsonConverters.toDouble(json['baseCapacityRate']);
        capacityRate = JsonConverters.toDouble(json['capacityRate']);
        chargeEfficiency = JsonConverters.toDouble(json['chargeEfficiency']);
        disChargeEfficiency = JsonConverters.toDouble(json['disChargeEfficiency']);
        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']);
        thermalLosses = JsonConverters.toDouble(json['thermalLosses']);
        otherLosses = JsonConverters.toDouble(json['otherLosses']);
        useEnergy = JsonConverters.fromJson(json['useEnergy'],'BooleanValue',context!);
        useCapacity = JsonConverters.fromJson(json['useCapacity'],'BooleanValue',context!);
        capacityBasis = JsonConverters.fromJson(json['capacityBasis'],'CapacityMethod',context!);
        capacityPayment = JsonConverters.toDouble(json['capacityPayment']);
        netCapacityFactor = JsonConverters.toDouble(json['netCapacityFactor']);
        useAncillary = JsonConverters.fromJson(json['useAncillary'],'BooleanValue',context!);
        productionDataSource = JsonConverters.fromJson(json['productionDataSource'],'BatteryProductionDataSource',context!);
        powerPlantType = JsonConverters.fromJson(json['powerPlantType'],'PowerPlantType',context!);
        solarAcCapacity = JsonConverters.toDouble(json['solarAcCapacity']);
        solarDcCapacity = JsonConverters.toDouble(json['solarDcCapacity']);
        windAcCapacity = JsonConverters.toDouble(json['windAcCapacity']);
        solarCapacityRate = JsonConverters.toDouble(json['solarCapacityRate']);
        windCapacityRate = JsonConverters.toDouble(json['windCapacityRate']);
        status = json['status'];
        simulationStatus = json['simulationStatus'];
        lastSimulationDate = JsonConverters.fromJson(json['lastSimulationDate'],'DateTime',context!);
        dataStartDate = JsonConverters.fromJson(json['dataStartDate'],'DateTime',context!);
        dataEndDate = JsonConverters.fromJson(json['dataEndDate'],'DateTime',context!);
        solarId = json['solarId'];
        windId = json['windId'];
        lmpFileId = json['lmpFileId'];
        productionFileId = json['productionFileId'];
        loadFileId = json['loadFileId'];
        capacityFileId = json['capacityFileId'];
        nodeAltId = json['nodeAltId'];
        nodeRefId = json['nodeRefId'];
        useRegup = JsonConverters.toDouble(json['useRegup']);
        useRegdown = JsonConverters.toDouble(json['useRegdown']);
        useSpinning = JsonConverters.toDouble(json['useSpinning']);
        useNonSpinning = JsonConverters.toDouble(json['useNonSpinning']);
        solarDegredation = JsonConverters.toDouble(json['solarDegredation']);
        batteryDegredation = JsonConverters.toDouble(json['batteryDegredation']);
        augmentation = JsonConverters.toDouble(json['augmentation']);
        augmentationFrequency = JsonConverters.toDouble(json['augmentationFrequency']);
        energyIncrement = JsonConverters.toDouble(json['energyIncrement']);
        ancillaryIncrement = JsonConverters.toDouble(json['ancillaryIncrement']);
        enableGridArbitrage = json['enableGridArbitrage'];
        incrementReferanceYear = json['incrementReferanceYear'];
        representativeYear = json['representativeYear'];
        useFutureData = json['useFutureData'];
        maxDailyCycle = JsonConverters.toDouble(json['maxDailyCycle']);
        minDailyProfitPerMw = JsonConverters.toDouble(json['minDailyProfitPerMw']);
        ancillaryFileId = json['ancillaryFileId'];
        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'];
        useInternalSolver = json['useInternalSolver'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'projectId': projectId,
        'version': version,
        'baseId': baseId,
        'altId': altId,
        'simulationType': JsonConverters.toJson(simulationType,'BatterySimulationType',context!),
        'projectGroup': JsonConverters.toJson(projectGroup,'BatteryProjectGroup',context!),
        'projectAction': JsonConverters.toJson(projectAction,'BatteryProjectAction',context!),
        'iso': JsonConverters.toJson(iso,'DataProvider',context!),
        'name': name,
        'baseNodeId': baseNodeId,
        'orgNodeId': orgNodeId,
        'baseZoneId': baseZoneId,
        'dataSource': JsonConverters.toJson(dataSource,'BatteryDataSoruce',context!),
        'baseMarket': JsonConverters.toJson(baseMarket,'PriceMarketType',context!),
        'priceGranularity': JsonConverters.toJson(priceGranularity,'TimeGranularity',context!),
        'startDate': JsonConverters.toJson(startDate,'DateTime',context!),
        'endDate': JsonConverters.toJson(endDate,'DateTime',context!),
        'batteryCapacity': batteryCapacity,
        'interconnectionLimit': interconnectionLimit,
        'namepaletCapacity': namepaletCapacity,
        'chargeDischargeLimit': chargeDischargeLimit,
        'baseCapacityRate': baseCapacityRate,
        'capacityRate': capacityRate,
        'chargeEfficiency': chargeEfficiency,
        'disChargeEfficiency': disChargeEfficiency,
        'paraciticLossesOperation': paraciticLossesOperation,
        'paraciticLossesResting': paraciticLossesResting,
        'hvacLosses': hvacLosses,
        'acCablingLosses': acCablingLosses,
        'transformatorLosses': transformatorLosses,
        'thermalLosses': thermalLosses,
        'otherLosses': otherLosses,
        'useEnergy': JsonConverters.toJson(useEnergy,'BooleanValue',context!),
        'useCapacity': JsonConverters.toJson(useCapacity,'BooleanValue',context!),
        'capacityBasis': JsonConverters.toJson(capacityBasis,'CapacityMethod',context!),
        'capacityPayment': capacityPayment,
        'netCapacityFactor': netCapacityFactor,
        'useAncillary': JsonConverters.toJson(useAncillary,'BooleanValue',context!),
        'productionDataSource': JsonConverters.toJson(productionDataSource,'BatteryProductionDataSource',context!),
        'powerPlantType': JsonConverters.toJson(powerPlantType,'PowerPlantType',context!),
        'solarAcCapacity': solarAcCapacity,
        'solarDcCapacity': solarDcCapacity,
        'windAcCapacity': windAcCapacity,
        'solarCapacityRate': solarCapacityRate,
        'windCapacityRate': windCapacityRate,
        'status': status,
        'simulationStatus': simulationStatus,
        'lastSimulationDate': JsonConverters.toJson(lastSimulationDate,'DateTime',context!),
        'dataStartDate': JsonConverters.toJson(dataStartDate,'DateTime',context!),
        'dataEndDate': JsonConverters.toJson(dataEndDate,'DateTime',context!),
        'solarId': solarId,
        'windId': windId,
        'lmpFileId': lmpFileId,
        'productionFileId': productionFileId,
        'loadFileId': loadFileId,
        'capacityFileId': capacityFileId,
        'nodeAltId': nodeAltId,
        'nodeRefId': nodeRefId,
        'useRegup': useRegup,
        'useRegdown': useRegdown,
        'useSpinning': useSpinning,
        'useNonSpinning': useNonSpinning,
        'solarDegredation': solarDegredation,
        'batteryDegredation': batteryDegredation,
        'augmentation': augmentation,
        'augmentationFrequency': augmentationFrequency,
        'energyIncrement': energyIncrement,
        'ancillaryIncrement': ancillaryIncrement,
        'enableGridArbitrage': enableGridArbitrage,
        'incrementReferanceYear': incrementReferanceYear,
        'representativeYear': representativeYear,
        'useFutureData': useFutureData,
        'maxDailyCycle': maxDailyCycle,
        'minDailyProfitPerMw': minDailyProfitPerMw,
        'ancillaryFileId': ancillaryFileId,
        'maxChargingPriceCap': maxChargingPriceCap,
        'maxDischargingPriceCap': maxDischargingPriceCap,
        'maxAncillaryPriceCap': maxAncillaryPriceCap,
        'revenueStackingMode': JsonConverters.toJson(revenueStackingMode,'RevenueStackingMode',context!),
        'optimizationQuality': optimizationQuality,
        'useInternalSolver': useInternalSolver
    };

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

class CommonOptimizerResponse implements IConvertible
{
    ApiResponseStatus? status;
    String? message;
    String? apiActionId;
    String? detail;
    List<BatteryProjectForOptimizer>? items;

    CommonOptimizerResponse({this.status,this.message,this.apiActionId,this.detail,this.items});
    CommonOptimizerResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        status = JsonConverters.fromJson(json['status'],'ApiResponseStatus',context!);
        message = json['message'];
        apiActionId = json['apiActionId'];
        detail = json['detail'];
        items = JsonConverters.fromJson(json['items'],'List<BatteryProjectForOptimizer>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'status': JsonConverters.toJson(status,'ApiResponseStatus',context!),
        'message': message,
        'apiActionId': apiActionId,
        'detail': detail,
        'items': JsonConverters.toJson(items,'List<BatteryProjectForOptimizer>',context!)
    };

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

// @Route("/optimizer/ftm", "POST")
// @Route("/optimizer/common", "POST")
class CommonOptimizerRequest extends CommonOptimizerPortalRequestBase implements IReturn<CommonOptimizerResponse>, IConvertible, IPost
{
    CommonOptimizerRequest();
    CommonOptimizerRequest.fromJson(Map<String, dynamic> json) : super.fromJson(json);
    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson();
    createResponse() => CommonOptimizerResponse();
    getResponseTypeName() => "CommonOptimizerResponse";
    getTypeName() => "CommonOptimizerRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'dev_optimization.power.dev', types: <String, TypeInfo> {
    'CommonOptimizerPortalRequestBase': TypeInfo(TypeOf.Class, create:() => CommonOptimizerPortalRequestBase()),
    'BatteryProjectGroup': TypeInfo(TypeOf.Enum, enumValues:BatteryProjectGroup.values),
    'DataProvider': TypeInfo(TypeOf.Enum, enumValues:DataProvider.values),
    'BooleanValue': TypeInfo(TypeOf.Enum, enumValues:BooleanValue.values),
    'PriceMarketType': TypeInfo(TypeOf.Enum, enumValues:PriceMarketType.values),
    'RevenueStackingMode': TypeInfo(TypeOf.Enum, enumValues:RevenueStackingMode.values),
    'ApiResponseStatus': TypeInfo(TypeOf.Enum, enumValues:ApiResponseStatus.values),
    'BatterySimulationType': TypeInfo(TypeOf.Enum, enumValues:BatterySimulationType.values),
    'BatteryProjectAction': TypeInfo(TypeOf.Enum, enumValues:BatteryProjectAction.values),
    'BatteryDataSoruce': TypeInfo(TypeOf.Enum, enumValues:BatteryDataSoruce.values),
    'TimeGranularity': TypeInfo(TypeOf.Enum, enumValues:TimeGranularity.values),
    'CapacityMethod': TypeInfo(TypeOf.Enum, enumValues:CapacityMethod.values),
    'BatteryProductionDataSource': TypeInfo(TypeOf.Enum, enumValues:BatteryProductionDataSource.values),
    'PowerPlantType': TypeInfo(TypeOf.Enum, enumValues:PowerPlantType.values),
    'BatteryProjectForOptimizer': TypeInfo(TypeOf.Class, create:() => BatteryProjectForOptimizer()),
    'CommonOptimizerResponse': TypeInfo(TypeOf.Class, create:() => CommonOptimizerResponse()),
    'List<BatteryProjectForOptimizer>': TypeInfo(TypeOf.Class, create:() => <BatteryProjectForOptimizer>[]),
    'CommonOptimizerRequest': TypeInfo(TypeOf.Class, create:() => CommonOptimizerRequest()),
});