/* Options:
Date: 2026-09-24 02:32:32
Version: 10.05
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://testapi.bokamera.se

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

import 'package:servicestack/servicestack.dart';

enum ProductTypeEnum
{
    Main,
    Addon,
    License,
    Usage,
}

enum PeriodAnchorEnum
{
    LatestPeriod,
    CurrentPeriod,
}

enum TypeEnum
{
    AtSubscriptionBillingPeriodEnd,
    AtBindingPeriodEnd,
}

enum ProductGroupTypeEnum
{
    Optional,
    Included,
}

enum StatusEnum
{
    Active,
    Terminated,
}

enum PackageStatusEnum
{
    Draft,
    Staged,
    Published,
    Archived,
    Discarded,
}

// @DataContract(Name="ProductGroupTagDto")
class ProductGroupTagDto implements IConvertible
{
    // @DataMember(Name="type", IsRequired=true)
    TypeEnum type;

    // @DataMember(Name="tag", IsRequired=true)
    String tag = "";

    ProductGroupTagDto({this.type,this.tag});
    ProductGroupTagDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['Type'],'TypeEnum',context!);
        tag = json['Tag'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'TypeEnum',context!),
        'tag': tag
    };

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

// @DataContract(Name="PackageProductDto")
class PackageProductDto implements IConvertible
{
    // @DataMember(Name="type", IsRequired=true)
    ProductTypeEnum type;

    // @DataMember(Name="status", IsRequired=true)
    StatusEnum status;

    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="name", IsRequired=true)
    String name = "";

    // @DataMember(Name="externalId")
    String externalId = "";

    // @DataMember(Name="articleNumber")
    String articleNumber = "";

    PackageProductDto({this.type,this.status,this.id,this.name,this.externalId,this.articleNumber});
    PackageProductDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['ProductType'],'ProductTypeEnum',context!);
        status = JsonConverters.fromJson(json['Status'],'StatusEnum',context!);
        id = json['Id'];
        name = json['Name'];
        externalId = json['ExternalId'];
        articleNumber = json['ArticleNumber'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'ProductTypeEnum',context!),
        'status': JsonConverters.toJson(status,'StatusEnum',context!),
        'id': id,
        'name': name,
        'externalId': externalId,
        'articleNumber': articleNumber
    };

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

// @DataContract(Name="PackageProductGroupDto")
class PackageProductGroupDto implements IConvertible
{
    // @DataMember(Name="productGroupType", IsRequired=true)
    ProductGroupTypeEnum productGroupType;

    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="name", IsRequired=true)
    String name = "";

    // @DataMember(Name="externalId")
    String externalId = "";

    // @DataMember(Name="tags", EmitDefaultValue=false)
    List<ProductGroupTagDto> tags = [];

    // @DataMember(Name="products", EmitDefaultValue=false)
    List<PackageProductDto> products = [];

    PackageProductGroupDto({this.productGroupType,this.id,this.name,this.externalId,this.tags,this.products});
    PackageProductGroupDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        productGroupType = JsonConverters.fromJson(json['ProductGroupType'],'ProductGroupTypeEnum',context!);
        id = json['Id'];
        name = json['Name'];
        externalId = json['ExternalId'];
        tags = JsonConverters.fromJson(json['Tags'],'List<ProductGroupTagDto>',context!);
        products = JsonConverters.fromJson(json['Products'],'List<PackageProductDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'productGroupType': JsonConverters.toJson(productGroupType,'ProductGroupTypeEnum',context!),
        'id': id,
        'name': name,
        'externalId': externalId,
        'tags': JsonConverters.toJson(tags,'List<ProductGroupTagDto>',context!),
        'products': JsonConverters.toJson(products,'List<PackageProductDto>',context!)
    };

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

// @DataContract(Name="PackageTierDto")
class PackageTierDto implements IConvertible
{
    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="name", IsRequired=true)
    String name = "";

    // @DataMember(Name="externalId")
    String externalId = "";

    // @DataMember(Name="productGroups", EmitDefaultValue=false)
    List<PackageProductGroupDto> productGroups = [];

    PackageTierDto({this.id,this.name,this.externalId,this.productGroups});
    PackageTierDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['Id'];
        name = json['Name'];
        externalId = json['ExternalId'];
        productGroups = JsonConverters.fromJson(json['ProductGroups'],'List<PackageProductGroupDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'externalId': externalId,
        'productGroups': JsonConverters.toJson(productGroups,'List<PackageProductGroupDto>',context!)
    };

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

enum PeriodEndActionEnum
{
    Renew,
    Terminate,
}

enum UnitEnum
{
    Day,
    Month,
    Year,
}

// @DataContract(Name="TimeLengthDto")
class TimeLengthDto implements IConvertible
{
    // @DataMember(Name="unit", IsRequired=true)
    UnitEnum unit;

    // @DataMember(Name="value", EmitDefaultValue=false)
    int value = 0;

    TimeLengthDto({this.unit,this.value});
    TimeLengthDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        unit = JsonConverters.fromJson(json['Unit'],'UnitEnum',context!);
        value = json['Value'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'unit': JsonConverters.toJson(unit,'UnitEnum',context!),
        'value': value
    };

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

// @DataContract(Name="BindingPeriodCycleDto")
class BindingPeriodCycleDto implements IConvertible
{
    // @DataMember(Name="periodEndAction", IsRequired=true)
    PeriodEndActionEnum periodEndAction;

    // @DataMember(Name="length", IsRequired=true)
    TimeLengthDto length;

    BindingPeriodCycleDto({this.periodEndAction,this.length});
    BindingPeriodCycleDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        periodEndAction = JsonConverters.fromJson(json['PeriodEndAction'],'PeriodEndActionEnum',context!);
        length = JsonConverters.fromJson(json['Length'],'TimeLengthDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'periodEndAction': JsonConverters.toJson(periodEndAction,'PeriodEndActionEnum',context!),
        'length': JsonConverters.toJson(length,'TimeLengthDto',context!)
    };

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

// @DataContract(Name="PeriodDateOffsetDto")
class PeriodDateOffsetDto implements IConvertible
{
    // @DataMember(Name="periodAnchor", IsRequired=true)
    PeriodAnchorEnum periodAnchor;

    // @DataMember(Name="length", IsRequired=true)
    TimeLengthDto length;

    // @DataMember(Name="valueAnchor")
    int? valueAnchor;

    PeriodDateOffsetDto({this.periodAnchor,this.length,this.valueAnchor});
    PeriodDateOffsetDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        periodAnchor = JsonConverters.fromJson(json['PeriodAnchor'],'PeriodAnchorEnum',context!);
        length = JsonConverters.fromJson(json['Length'],'TimeLengthDto',context!);
        valueAnchor = json['ValueAnchor'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'periodAnchor': JsonConverters.toJson(periodAnchor,'PeriodAnchorEnum',context!),
        'length': JsonConverters.toJson(length,'TimeLengthDto',context!),
        'valueAnchor': valueAnchor
    };

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

// @DataContract(Name="BillingPeriodCycleDto")
class BillingPeriodCycleDto implements IConvertible
{
    // @DataMember(Name="length", IsRequired=true)
    TimeLengthDto length;

    // @DataMember(Name="invoiceDateOffset", IsRequired=true)
    PeriodDateOffsetDto invoiceDateOffset;

    // @DataMember(Name="renewalDateOffset", IsRequired=true)
    PeriodDateOffsetDto renewalDateOffset;

    BillingPeriodCycleDto({this.length,this.invoiceDateOffset,this.renewalDateOffset});
    BillingPeriodCycleDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        length = JsonConverters.fromJson(json['Length'],'TimeLengthDto',context!);
        invoiceDateOffset = JsonConverters.fromJson(json['InvoiceDateOffset'],'PeriodDateOffsetDto',context!);
        renewalDateOffset = JsonConverters.fromJson(json['RenewalDateOffset'],'PeriodDateOffsetDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'length': JsonConverters.toJson(length,'TimeLengthDto',context!),
        'invoiceDateOffset': JsonConverters.toJson(invoiceDateOffset,'PeriodDateOffsetDto',context!),
        'renewalDateOffset': JsonConverters.toJson(renewalDateOffset,'PeriodDateOffsetDto',context!)
    };

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

// @DataContract(Name="PackagePlanDto")
class PackagePlanDto implements IConvertible
{
    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="name", IsRequired=true)
    String name = "";

    // @DataMember(Name="externalId")
    String externalId = "";

    // @DataMember(Name="bindingPeriodCycle", IsRequired=true)
    BindingPeriodCycleDto bindingPeriodCycle;

    // @DataMember(Name="subscriptionBillingPeriodCycle", IsRequired=true)
    BillingPeriodCycleDto subscriptionBillingPeriodCycle;

    // @DataMember(Name="usageBillingPeriodCycle", IsRequired=true)
    BillingPeriodCycleDto usageBillingPeriodCycle;

    PackagePlanDto({this.id,this.name,this.externalId,this.bindingPeriodCycle,this.subscriptionBillingPeriodCycle,this.usageBillingPeriodCycle});
    PackagePlanDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['Id'];
        name = json['Name'];
        externalId = json['ExternalId'];
        bindingPeriodCycle = JsonConverters.fromJson(json['BindingPeriodCycle'],'BindingPeriodCycleDto',context!);
        subscriptionBillingPeriodCycle = JsonConverters.fromJson(json['SubscriptionBillingPeriodCycle'],'BillingPeriodCycleDto',context!);
        usageBillingPeriodCycle = JsonConverters.fromJson(json['UsageBillingPeriodCycle'],'BillingPeriodCycleDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'externalId': externalId,
        'bindingPeriodCycle': JsonConverters.toJson(bindingPeriodCycle,'BindingPeriodCycleDto',context!),
        'subscriptionBillingPeriodCycle': JsonConverters.toJson(subscriptionBillingPeriodCycle,'BillingPeriodCycleDto',context!),
        'usageBillingPeriodCycle': JsonConverters.toJson(usageBillingPeriodCycle,'BillingPeriodCycleDto',context!)
    };

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

enum PricingSchemeEnum
{
    UnitPricing,
    TierPricing,
}

// @DataContract(Name="ProductTierPricingDto")
class ProductTierPricingDto implements IConvertible
{
    // @DataMember(Name="index", EmitDefaultValue=false)
    int index = 0;

    // @DataMember(Name="unitPrice", EmitDefaultValue=false)
    double unitPrice = 0;

    // @DataMember(Name="flatPrice", EmitDefaultValue=false)
    double flatPrice = 0;

    // @DataMember(Name="repeatEvery")
    int? repeatEvery;

    // @DataMember(Name="upperLimit")
    int? upperLimit;

    ProductTierPricingDto({this.index,this.unitPrice,this.flatPrice,this.repeatEvery,this.upperLimit});
    ProductTierPricingDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        index = json['Index'];
        unitPrice = JsonConverters.toDouble(json['UnitPrice']);
        flatPrice = JsonConverters.toDouble(json['FlatPrice']);
        repeatEvery = json['RepeatEvery'];
        upperLimit = json['UpperLimit'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'index': index,
        'unitPrice': unitPrice,
        'flatPrice': flatPrice,
        'repeatEvery': repeatEvery,
        'upperLimit': upperLimit
    };

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

// @DataContract(Name="ProductPricingDto")
class ProductPricingDto implements IConvertible
{
    // @DataMember(Name="pricingScheme", IsRequired=true)
    PricingSchemeEnum pricingScheme;

    // @DataMember(Name="productId", IsRequired=true)
    String productId = "";

    // @DataMember(Name="includedQuantity")
    int? includedQuantity;

    // @DataMember(Name="maxQuantity")
    int? maxQuantity;

    // @DataMember(Name="unitPrice")
    double? unitPrice;

    // @DataMember(Name="tierPricing", EmitDefaultValue=false)
    List<ProductTierPricingDto> tierPricing = [];

    // @DataMember(Name="articleNumber")
    String articleNumber = "";

    ProductPricingDto({this.pricingScheme,this.productId,this.includedQuantity,this.maxQuantity,this.unitPrice,this.tierPricing,this.articleNumber});
    ProductPricingDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        pricingScheme = JsonConverters.fromJson(json['PricingScheme'],'PricingSchemeEnum',context!);
        productId = json['ProductId'];
        includedQuantity = json['IncludedQuantity'];
        maxQuantity = json['MaxQuantity'];
        unitPrice = JsonConverters.toDouble(json['UnitPrice']);
        tierPricing = JsonConverters.fromJson(json['TierPricing'],'List<ProductTierPricingDto>',context!);
        articleNumber = json['ArticleNumber'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'pricingScheme': JsonConverters.toJson(pricingScheme,'PricingSchemeEnum',context!),
        'productId': productId,
        'includedQuantity': includedQuantity,
        'maxQuantity': maxQuantity,
        'unitPrice': unitPrice,
        'tierPricing': JsonConverters.toJson(tierPricing,'List<ProductTierPricingDto>',context!),
        'articleNumber': articleNumber
    };

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

// @DataContract(Name="ProductGroupPricingDto")
class ProductGroupPricingDto implements IConvertible
{
    // @DataMember(Name="productGroupId", IsRequired=true)
    String productGroupId = "";

    // @DataMember(Name="articleNumber", IsRequired=true)
    String articleNumber = "";

    // @DataMember(Name="price", EmitDefaultValue=false)
    double price = 0;

    // @DataMember(Name="productPricings", EmitDefaultValue=false)
    List<ProductPricingDto> productPricings = [];

    ProductGroupPricingDto({this.productGroupId,this.articleNumber,this.price,this.productPricings});
    ProductGroupPricingDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        productGroupId = json['ProductGroupId'];
        articleNumber = json['ArticleNumber'];
        price = JsonConverters.toDouble(json['Price']);
        productPricings = JsonConverters.fromJson(json['ProductPricings'],'List<ProductPricingDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'productGroupId': productGroupId,
        'articleNumber': articleNumber,
        'price': price,
        'productPricings': JsonConverters.toJson(productPricings,'List<ProductPricingDto>',context!)
    };

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

// @DataContract(Name="PackageChargePlanDto")
class PackageChargePlanDto implements IConvertible
{
    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="tierId", IsRequired=true)
    String tierId = "";

    // @DataMember(Name="planId", IsRequired=true)
    String planId = "";

    // @DataMember(Name="productGroupPricings", IsRequired=true)
    List<ProductGroupPricingDto> productGroupPricings = [];

    PackageChargePlanDto({this.id,this.tierId,this.planId,this.productGroupPricings});
    PackageChargePlanDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['Id'];
        tierId = json['TierId'];
        planId = json['PlanId'];
        productGroupPricings = JsonConverters.fromJson(json['ProductGroupPricings'],'List<ProductGroupPricingDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'tierId': tierId,
        'planId': planId,
        'productGroupPricings': JsonConverters.toJson(productGroupPricings,'List<ProductGroupPricingDto>',context!)
    };

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

// @DataContract(Name="PackageSalesChannelDto")
class PackageSalesChannelDto implements IConvertible
{
    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="name", IsRequired=true)
    String name = "";

    // @DataMember(Name="description")
    String description = "";

    // @DataMember(Name="validFrom")
    DateTime? validFrom;

    // @DataMember(Name="validTo")
    DateTime? validTo;

    PackageSalesChannelDto({this.id,this.name,this.description,this.validFrom,this.validTo});
    PackageSalesChannelDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['Id'];
        name = json['Name'];
        description = json['Description'];
        validFrom = JsonConverters.fromJson(json['ValidFrom'],'DateTime',context!);
        validTo = JsonConverters.fromJson(json['ValidTo'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'description': description,
        'validFrom': JsonConverters.toJson(validFrom,'DateTime',context!),
        'validTo': JsonConverters.toJson(validTo,'DateTime',context!)
    };

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

// @DataContract(Name="PackageTargetGroupDto")
class PackageTargetGroupDto implements IConvertible
{
    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="name", IsRequired=true)
    String name = "";

    // @DataMember(Name="isDefault")
    bool isDefault;

    // @DataMember(Name="externalId")
    String externalId = "";

    PackageTargetGroupDto({this.id,this.name,this.isDefault,this.externalId});
    PackageTargetGroupDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['Id'];
        name = json['Name'];
        isDefault = json['IsDefault'];
        externalId = json['ExternalId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'isDefault': isDefault,
        'externalId': externalId
    };

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

// @DataContract(Name="PackageScheduledChangeResultDto")
class PackageScheduledChangeResultDto implements IConvertible
{
    // @DataMember(Name="status")
    PackageStatusEnum? status;

    // @DataMember(Name="name")
    String name = "";

    PackageScheduledChangeResultDto({this.status,this.name});
    PackageScheduledChangeResultDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        status = JsonConverters.fromJson(json['Status'],'PackageStatusEnum',context!);
        name = json['Name'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'status': JsonConverters.toJson(status,'PackageStatusEnum',context!),
        'name': name
    };

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

// @DataContract(Name="PackageScheduledChangeResult")
class PackageScheduledChangeResult implements IConvertible
{
    // @DataMember(Name="status", IsRequired=true)
    StatusEnum status;

    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="versionId", IsRequired=true)
    String versionId = "";

    // @DataMember(Name="package", EmitDefaultValue=false)
    PackageScheduledChangeResultDto package;

    // @DataMember(Name="scheduledDate", IsRequired=true)
    DateTime scheduledDate = DateTime(0);

    PackageScheduledChangeResult({this.status,this.id,this.versionId,this.package,this.scheduledDate});
    PackageScheduledChangeResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        status = JsonConverters.fromJson(json['Status'],'StatusEnum',context!);
        id = json['Id'];
        versionId = json['VersionId'];
        package = JsonConverters.fromJson(json['Package'],'PackageScheduledChangeResultDto',context!);
        scheduledDate = JsonConverters.fromJson(json['ScheduledDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'status': JsonConverters.toJson(status,'StatusEnum',context!),
        'id': id,
        'versionId': versionId,
        'package': JsonConverters.toJson(package,'PackageScheduledChangeResultDto',context!),
        'scheduledDate': JsonConverters.toJson(scheduledDate,'DateTime',context!)
    };

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

enum PeriodAnchorEnum
{
    PeriodCreated,
    PeriodStart,
    PeriodEnd,
}

// @DataContract(Name="PackageResult")
class PackageResult implements IConvertible
{
    // @DataMember(Name="status", IsRequired=true)
    PackageStatusEnum status;

    // @DataMember(Name="id", IsRequired=true)
    String id = "";

    // @DataMember(Name="versionId", IsRequired=true)
    String versionId = "";

    // @DataMember(Name="sourceVersionId")
    String? sourceVersionId;

    // @DataMember(Name="name", IsRequired=true)
    String name = "";

    // @DataMember(Name="externalId")
    String externalId = "";

    // @DataMember(Name="tiers", IsRequired=true)
    List<PackageTierDto> tiers = [];

    // @DataMember(Name="plans", IsRequired=true)
    List<PackagePlanDto> plans = [];

    // @DataMember(Name="chargePlans", IsRequired=true)
    List<PackageChargePlanDto> chargePlans = [];

    // @DataMember(Name="salesChannels", IsRequired=true)
    List<PackageSalesChannelDto> salesChannels = [];

    // @DataMember(Name="targetGroups", IsRequired=true)
    List<PackageTargetGroupDto> targetGroups = [];

    // @DataMember(Name="scheduledChanges", IsRequired=true)
    List<PackageScheduledChangeResult> scheduledChanges = [];

    PackageResult({this.status,this.id,this.versionId,this.sourceVersionId,this.name,this.externalId,this.tiers,this.plans,this.chargePlans,this.salesChannels,this.targetGroups,this.scheduledChanges});
    PackageResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        status = JsonConverters.fromJson(json['PackageStatus'],'PackageStatusEnum',context!);
        id = json['Id'];
        versionId = json['VersionId'];
        sourceVersionId = json['SourceVersionId'];
        name = json['Name'];
        externalId = json['ExternalId'];
        tiers = JsonConverters.fromJson(json['Tiers'],'List<PackageTierDto>',context!);
        plans = JsonConverters.fromJson(json['Plans'],'List<PackagePlanDto>',context!);
        chargePlans = JsonConverters.fromJson(json['ChargePlans'],'List<PackageChargePlanDto>',context!);
        salesChannels = JsonConverters.fromJson(json['SalesChannels'],'List<PackageSalesChannelDto>',context!);
        targetGroups = JsonConverters.fromJson(json['TargetGroups'],'List<PackageTargetGroupDto>',context!);
        scheduledChanges = JsonConverters.fromJson(json['ScheduledChanges'],'List<PackageScheduledChangeResult>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'status': JsonConverters.toJson(status,'PackageStatusEnum',context!),
        'id': id,
        'versionId': versionId,
        'sourceVersionId': sourceVersionId,
        'name': name,
        'externalId': externalId,
        'tiers': JsonConverters.toJson(tiers,'List<PackageTierDto>',context!),
        'plans': JsonConverters.toJson(plans,'List<PackagePlanDto>',context!),
        'chargePlans': JsonConverters.toJson(chargePlans,'List<PackageChargePlanDto>',context!),
        'salesChannels': JsonConverters.toJson(salesChannels,'List<PackageSalesChannelDto>',context!),
        'targetGroups': JsonConverters.toJson(targetGroups,'List<PackageTargetGroupDto>',context!),
        'scheduledChanges': JsonConverters.toJson(scheduledChanges,'List<PackageScheduledChangeResult>',context!)
    };

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

// @Route("/voss/packages", "GET")
// @ApiResponse(Description="You were unauthorized to call this service", StatusCode=401)
class GetVossPackage implements IReturn<PackageResult>, IConvertible, IGet
{
    /**
    * The package id; if not passed the configured BokaMera package will be used.
    */
    // @ApiMember(Description="The package id; if not passed the configured BokaMera package will be used.")
    String? PackageId;

    GetVossPackage({this.PackageId});
    GetVossPackage.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

    createResponse() => PackageResult();
    getResponseTypeName() => "PackageResult";
    getTypeName() => "GetVossPackage";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'testapi.bokamera.se', types: <String, TypeInfo> {
    'ProductTypeEnum': TypeInfo(TypeOf.Enum, enumValues:ProductTypeEnum.values),
    'PeriodAnchorEnum': TypeInfo(TypeOf.Enum, enumValues:PeriodAnchorEnum.values),
    'TypeEnum': TypeInfo(TypeOf.Enum, enumValues:TypeEnum.values),
    'ProductGroupTypeEnum': TypeInfo(TypeOf.Enum, enumValues:ProductGroupTypeEnum.values),
    'StatusEnum': TypeInfo(TypeOf.Enum, enumValues:StatusEnum.values),
    'PackageStatusEnum': TypeInfo(TypeOf.Enum, enumValues:PackageStatusEnum.values),
    'ProductGroupTagDto': TypeInfo(TypeOf.Class, create:() => ProductGroupTagDto()),
    'PackageProductDto': TypeInfo(TypeOf.Class, create:() => PackageProductDto()),
    'PackageProductGroupDto': TypeInfo(TypeOf.Class, create:() => PackageProductGroupDto()),
    'List<ProductGroupTagDto>': TypeInfo(TypeOf.Class, create:() => <ProductGroupTagDto>[]),
    'List<PackageProductDto>': TypeInfo(TypeOf.Class, create:() => <PackageProductDto>[]),
    'PackageTierDto': TypeInfo(TypeOf.Class, create:() => PackageTierDto()),
    'List<PackageProductGroupDto>': TypeInfo(TypeOf.Class, create:() => <PackageProductGroupDto>[]),
    'PeriodEndActionEnum': TypeInfo(TypeOf.Enum, enumValues:PeriodEndActionEnum.values),
    'UnitEnum': TypeInfo(TypeOf.Enum, enumValues:UnitEnum.values),
    'TimeLengthDto': TypeInfo(TypeOf.Class, create:() => TimeLengthDto()),
    'BindingPeriodCycleDto': TypeInfo(TypeOf.Class, create:() => BindingPeriodCycleDto()),
    'PeriodDateOffsetDto': TypeInfo(TypeOf.Class, create:() => PeriodDateOffsetDto()),
    'BillingPeriodCycleDto': TypeInfo(TypeOf.Class, create:() => BillingPeriodCycleDto()),
    'PackagePlanDto': TypeInfo(TypeOf.Class, create:() => PackagePlanDto()),
    'PricingSchemeEnum': TypeInfo(TypeOf.Enum, enumValues:PricingSchemeEnum.values),
    'ProductTierPricingDto': TypeInfo(TypeOf.Class, create:() => ProductTierPricingDto()),
    'ProductPricingDto': TypeInfo(TypeOf.Class, create:() => ProductPricingDto()),
    'List<ProductTierPricingDto>': TypeInfo(TypeOf.Class, create:() => <ProductTierPricingDto>[]),
    'ProductGroupPricingDto': TypeInfo(TypeOf.Class, create:() => ProductGroupPricingDto()),
    'List<ProductPricingDto>': TypeInfo(TypeOf.Class, create:() => <ProductPricingDto>[]),
    'PackageChargePlanDto': TypeInfo(TypeOf.Class, create:() => PackageChargePlanDto()),
    'List<ProductGroupPricingDto>': TypeInfo(TypeOf.Class, create:() => <ProductGroupPricingDto>[]),
    'PackageSalesChannelDto': TypeInfo(TypeOf.Class, create:() => PackageSalesChannelDto()),
    'PackageTargetGroupDto': TypeInfo(TypeOf.Class, create:() => PackageTargetGroupDto()),
    'PackageScheduledChangeResultDto': TypeInfo(TypeOf.Class, create:() => PackageScheduledChangeResultDto()),
    'PackageScheduledChangeResult': TypeInfo(TypeOf.Class, create:() => PackageScheduledChangeResult()),
    'PackageResult': TypeInfo(TypeOf.Class, create:() => PackageResult()),
    'List<PackageTierDto>': TypeInfo(TypeOf.Class, create:() => <PackageTierDto>[]),
    'List<PackagePlanDto>': TypeInfo(TypeOf.Class, create:() => <PackagePlanDto>[]),
    'List<PackageChargePlanDto>': TypeInfo(TypeOf.Class, create:() => <PackageChargePlanDto>[]),
    'List<PackageSalesChannelDto>': TypeInfo(TypeOf.Class, create:() => <PackageSalesChannelDto>[]),
    'List<PackageTargetGroupDto>': TypeInfo(TypeOf.Class, create:() => <PackageTargetGroupDto>[]),
    'List<PackageScheduledChangeResult>': TypeInfo(TypeOf.Class, create:() => <PackageScheduledChangeResult>[]),
    'GetVossPackage': TypeInfo(TypeOf.Class, create:() => GetVossPackage()),
});