/* Options:
Date: 2025-12-14 05:18:16
Version: 8.80
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.bokamera.se

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

import 'package:servicestack/servicestack.dart';

enum CreditKindEnum
{
    Normal,
    Internal,
}

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

enum SubscriptionBehaviourEnum
{
    Prorate,
    Full,
    None,
}

// @DataContract(Name="SubscriptionItemTerminationReasonDto")
class SubscriptionItemTerminationReasonDto implements IConvertible
{
    // @DataMember(Name="reasonId", IsRequired=true)
    String? reasonId;

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

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

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

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

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

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

    SubscriptionItemTerminationReasonDto({this.reasonId,this.reasonName,this.reasonExternalId,this.subReasonId,this.subReasonName,this.subReasonExternalId,this.comment});
    SubscriptionItemTerminationReasonDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        reasonId = json['ReasonId'];
        reasonName = json['ReasonName'];
        reasonExternalId = json['ReasonExternalId'];
        subReasonId = json['SubReasonId'];
        subReasonName = json['SubReasonName'];
        subReasonExternalId = json['SubReasonExternalId'];
        comment = json['Comment'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'reasonId': reasonId,
        'reasonName': reasonName,
        'reasonExternalId': reasonExternalId,
        'subReasonId': subReasonId,
        'subReasonName': subReasonName,
        'subReasonExternalId': subReasonExternalId,
        'comment': comment
    };

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

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

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

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

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

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

    // @DataMember(Name="quantity", IsRequired=true)
    double? quantity;

    // @DataMember(Name="amount", IsRequired=true)
    double? amount;

    // @DataMember(Name="discountAmount", IsRequired=true)
    double? discountAmount;

    // @DataMember(Name="totalAmount", EmitDefaultValue=false)
    double? totalAmount;

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

    CustomerBalanceChangeItemDto({this.type,this.id,this.name,this.productGroupId,this.productGroupName,this.quantity,this.amount,this.discountAmount,this.totalAmount,this.invoiceRecipientCustomerId});
    CustomerBalanceChangeItemDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['ProductType'],'ProductTypeEnum',context!);
        id = json['Id'];
        name = json['Name'];
        productGroupId = json['ProductGroupId'];
        productGroupName = json['ProductGroupName'];
        quantity = JsonConverters.toDouble(json['Quantity']);
        amount = JsonConverters.toDouble(json['Amount']);
        discountAmount = JsonConverters.toDouble(json['DiscountAmount']);
        totalAmount = JsonConverters.toDouble(json['TotalAmount']);
        invoiceRecipientCustomerId = json['InvoiceRecipientCustomerId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'ProductTypeEnum',context!),
        'id': id,
        'name': name,
        'productGroupId': productGroupId,
        'productGroupName': productGroupName,
        'quantity': quantity,
        'amount': amount,
        'discountAmount': discountAmount,
        'totalAmount': totalAmount,
        'invoiceRecipientCustomerId': invoiceRecipientCustomerId
    };

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

// @DataContract(Name="CustomerBalanceChangeDto")
class CustomerBalanceChangeDto implements IConvertible
{
    // @DataMember(Name="items", EmitDefaultValue=false)
    List<CustomerBalanceChangeItemDto>? items = [];

    // @DataMember(Name="totalAmount", EmitDefaultValue=false)
    double? totalAmount;

    // @DataMember(Name="totalDiscountAmount", EmitDefaultValue=false)
    double? totalDiscountAmount;

    CustomerBalanceChangeDto({this.items,this.totalAmount,this.totalDiscountAmount});
    CustomerBalanceChangeDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        items = JsonConverters.fromJson(json['Items'],'List<CustomerBalanceChangeItemDto>',context!);
        totalAmount = JsonConverters.toDouble(json['TotalAmount']);
        totalDiscountAmount = JsonConverters.toDouble(json['TotalDiscountAmount']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'items': JsonConverters.toJson(items,'List<CustomerBalanceChangeItemDto>',context!),
        'totalAmount': totalAmount,
        'totalDiscountAmount': totalDiscountAmount
    };

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

enum ProductGroupTypeEnum
{
    Optional,
    Included,
}

enum StatusEnum
{
    Active,
    Terminated,
}

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

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

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

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

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

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

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

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

enum TypeEnum
{
    AtSubscriptionBillingPeriodEnd,
    AtBindingPeriodEnd,
    Immediately,
}

enum SourceEnum
{
    Direct,
    Plan,
    CustomerExpiration,
    Update,
    Unpaid,
}

// @DataContract(Name="CreditOptionsDto")
class CreditOptionsDto implements IConvertible
{
    // @DataMember(Name="behaviour", IsRequired=true)
    SubscriptionBehaviourEnum? behaviour;

    // @DataMember(Name="creditKind", IsRequired=true)
    CreditKindEnum? creditKind;

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

    CreditOptionsDto({this.behaviour,this.creditKind,this.prorateTimeAnchor});
    CreditOptionsDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        behaviour = JsonConverters.fromJson(json['SubscriptionBehaviour'],'SubscriptionBehaviourEnum',context!);
        creditKind = JsonConverters.fromJson(json['CreditKind'],'CreditKindEnum',context!);
        prorateTimeAnchor = JsonConverters.fromJson(json['ProrateTimeAnchor'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'behaviour': JsonConverters.toJson(behaviour,'SubscriptionBehaviourEnum',context!),
        'creditKind': JsonConverters.toJson(creditKind,'CreditKindEnum',context!),
        'prorateTimeAnchor': JsonConverters.toJson(prorateTimeAnchor,'DateTime',context!)
    };

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

// @DataContract(Name="SubscriptionItemTerminationDto")
class SubscriptionItemTerminationDto implements IConvertible
{
    // @DataMember(Name="type")
    TypeEnum? type;

    // @DataMember(Name="source", IsRequired=true)
    SourceEnum? source;

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

    // @DataMember(Name="reason")
    SubscriptionItemTerminationReasonDto? reason;

    // @DataMember(Name="creditOptions", IsRequired=true)
    CreditOptionsDto? creditOptions;

    SubscriptionItemTerminationDto({this.type,this.source,this.scheduledDate,this.reason,this.creditOptions});
    SubscriptionItemTerminationDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['Type'],'TypeEnum',context!);
        source = JsonConverters.fromJson(json['Source'],'SourceEnum',context!);
        scheduledDate = JsonConverters.fromJson(json['ScheduledDate'],'DateTime',context!);
        reason = JsonConverters.fromJson(json['Reason'],'SubscriptionItemTerminationReasonDto',context!);
        creditOptions = JsonConverters.fromJson(json['CreditOptions'],'CreditOptionsDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'TypeEnum',context!),
        'source': JsonConverters.toJson(source,'SourceEnum',context!),
        'scheduledDate': JsonConverters.toJson(scheduledDate,'DateTime',context!),
        'reason': JsonConverters.toJson(reason,'SubscriptionItemTerminationReasonDto',context!),
        'creditOptions': JsonConverters.toJson(creditOptions,'CreditOptionsDto',context!)
    };

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

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

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

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

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

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

    // @DataMember(Name="termination")
    SubscriptionItemTerminationDto? termination;

    // @DataMember(Name="created", IsRequired=true)
    DateTime? created;

    // @DataMember(Name="customerBalanceChange", IsRequired=true)
    CustomerBalanceChangeDto? customerBalanceChange;

    CreateSubscriptionProductGroupResult({this.productGroupType,this.status,this.id,this.name,this.products,this.termination,this.created,this.customerBalanceChange});
    CreateSubscriptionProductGroupResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        productGroupType = JsonConverters.fromJson(json['ProductGroupType'],'ProductGroupTypeEnum',context!);
        status = JsonConverters.fromJson(json['Status'],'StatusEnum',context!);
        id = json['Id'];
        name = json['Name'];
        products = JsonConverters.fromJson(json['Products'],'List<SubscriptionProductGroupProductResultDto>',context!);
        termination = JsonConverters.fromJson(json['Termination'],'SubscriptionItemTerminationDto',context!);
        created = JsonConverters.fromJson(json['Created'],'DateTime',context!);
        customerBalanceChange = JsonConverters.fromJson(json['CustomerBalanceChange'],'CustomerBalanceChangeDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'productGroupType': JsonConverters.toJson(productGroupType,'ProductGroupTypeEnum',context!),
        'status': JsonConverters.toJson(status,'StatusEnum',context!),
        'id': id,
        'name': name,
        'products': JsonConverters.toJson(products,'List<SubscriptionProductGroupProductResultDto>',context!),
        'termination': JsonConverters.toJson(termination,'SubscriptionItemTerminationDto',context!),
        'created': JsonConverters.toJson(created,'DateTime',context!),
        'customerBalanceChange': JsonConverters.toJson(customerBalanceChange,'CustomerBalanceChangeDto',context!)
    };

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

// @Route("/voss/usage", "POST")
// @ApiResponse(Description="You were unauthorized to call this service", StatusCode=401)
// @ValidateRequest(Validator="IsAuthenticated")
class CreateVossUsage implements IReturn<CreateSubscriptionProductGroupResult>, IConvertible, IPost
{
    /**
    * The company id
    */
    // @ApiMember(Description="The company id", IsRequired=true)
    String? CompanyId;

    /**
    * Article number. Can be fetched from products
    */
    // @ApiMember(Description="Article number. Can be fetched from products", IsRequired=true)
    String? ArticleNumber;

    /**
    * Example: developer worked 6 hours
    */
    // @ApiMember(Description="Example: developer worked 6 hours", IsRequired=true)
    int? Quantity;

    CreateVossUsage({this.CompanyId,this.ArticleNumber,this.Quantity});
    CreateVossUsage.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'CompanyId': CompanyId,
        'ArticleNumber': ArticleNumber,
        'Quantity': Quantity
    };

    createResponse() => CreateSubscriptionProductGroupResult();
    getResponseTypeName() => "CreateSubscriptionProductGroupResult";
    getTypeName() => "CreateVossUsage";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.bokamera.se', types: <String, TypeInfo> {
    'CreditKindEnum': TypeInfo(TypeOf.Enum, enumValues:CreditKindEnum.values),
    'ProductTypeEnum': TypeInfo(TypeOf.Enum, enumValues:ProductTypeEnum.values),
    'SubscriptionBehaviourEnum': TypeInfo(TypeOf.Enum, enumValues:SubscriptionBehaviourEnum.values),
    'SubscriptionItemTerminationReasonDto': TypeInfo(TypeOf.Class, create:() => SubscriptionItemTerminationReasonDto()),
    'CustomerBalanceChangeItemDto': TypeInfo(TypeOf.Class, create:() => CustomerBalanceChangeItemDto()),
    'CustomerBalanceChangeDto': TypeInfo(TypeOf.Class, create:() => CustomerBalanceChangeDto()),
    'List<CustomerBalanceChangeItemDto>': TypeInfo(TypeOf.Class, create:() => <CustomerBalanceChangeItemDto>[]),
    'ProductGroupTypeEnum': TypeInfo(TypeOf.Enum, enumValues:ProductGroupTypeEnum.values),
    'StatusEnum': TypeInfo(TypeOf.Enum, enumValues:StatusEnum.values),
    'SubscriptionProductGroupProductResultDto': TypeInfo(TypeOf.Class, create:() => SubscriptionProductGroupProductResultDto()),
    'TypeEnum': TypeInfo(TypeOf.Enum, enumValues:TypeEnum.values),
    'SourceEnum': TypeInfo(TypeOf.Enum, enumValues:SourceEnum.values),
    'CreditOptionsDto': TypeInfo(TypeOf.Class, create:() => CreditOptionsDto()),
    'SubscriptionItemTerminationDto': TypeInfo(TypeOf.Class, create:() => SubscriptionItemTerminationDto()),
    'CreateSubscriptionProductGroupResult': TypeInfo(TypeOf.Class, create:() => CreateSubscriptionProductGroupResult()),
    'List<SubscriptionProductGroupProductResultDto>': TypeInfo(TypeOf.Class, create:() => <SubscriptionProductGroupProductResultDto>[]),
    'CreateVossUsage': TypeInfo(TypeOf.Class, create:() => CreateVossUsage()),
});