/* Options:
Date: 2025-12-14 05:19:12
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: CreateVossUsageTermination.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

enum UsageBehaviourEnum
{
    Full,
    None,
}

enum CreditKindEnum
{
    Normal,
    Internal,
}

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

// @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="UsageCreditOptionsDto")
class UsageCreditOptionsDto implements IConvertible
{
    // @DataMember(Name="behaviour", IsRequired=true)
    UsageBehaviourEnum? behaviour;

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

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

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

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

    getTypeName() => "UsageCreditOptionsDto";
    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;
}

// @DataContract(Name="CreateUsageTerminationResult")
class CreateUsageTerminationResult implements IConvertible
{
    // @DataMember(Name="scheduledDate", IsRequired=true)
    DateTime? scheduledDate;

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

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

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

    CreateUsageTerminationResult({this.scheduledDate,this.reason,this.creditOptions,this.customerBalanceChange});
    CreateUsageTerminationResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        scheduledDate = JsonConverters.fromJson(json['ScheduledDate'],'DateTime',context!);
        reason = JsonConverters.fromJson(json['Reason'],'SubscriptionItemTerminationReasonDto',context!);
        creditOptions = JsonConverters.fromJson(json['CreditOptions'],'UsageCreditOptionsDto',context!);
        customerBalanceChange = JsonConverters.fromJson(json['CustomerBalanceChange'],'CustomerBalanceChangeDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'scheduledDate': JsonConverters.toJson(scheduledDate,'DateTime',context!),
        'reason': JsonConverters.toJson(reason,'SubscriptionItemTerminationReasonDto',context!),
        'creditOptions': JsonConverters.toJson(creditOptions,'UsageCreditOptionsDto',context!),
        'customerBalanceChange': JsonConverters.toJson(customerBalanceChange,'CustomerBalanceChangeDto',context!)
    };

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

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

    /**
    * Usage Id
    */
    // @ApiMember(Description="Usage Id", IsRequired=true)
    String? Id;

    List<String>? InvoiceLineTexts = [];
    String? TerminationReasonComment;
    String? TerminationReasonId;
    /**
    * Credit behaviour:  &lt;br /&gt; 1. Full - usage will be credited in full  &lt;br /&gt; 2. None - no credit will be created
    */
    // @ApiMember(Description="Credit behaviour:  &lt;br /&gt; 1. Full - usage will be credited in full  &lt;br /&gt; 2. None - no credit will be created", IsRequired=true)
    UsageBehaviourEnum? Behaviour;

    /**
    * Credit kind:  &lt;br /&gt; 1. Normal - default credit type  &lt;br /&gt; 2. Internal - corresponding credit will be marked as internal in invoice file line
    */
    // @ApiMember(Description="Credit kind:  &lt;br /&gt; 1. Normal - default credit type  &lt;br /&gt; 2. Internal - corresponding credit will be marked as internal in invoice file line", IsRequired=true)
    CreditKindEnum? CreditKind;

    CreateVossUsageTermination({this.CompanyId,this.Id,this.InvoiceLineTexts,this.TerminationReasonComment,this.TerminationReasonId,this.Behaviour,this.CreditKind});
    CreateVossUsageTermination.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CompanyId = json['CompanyId'];
        Id = json['Id'];
        InvoiceLineTexts = JsonConverters.fromJson(json['InvoiceLineTexts'],'List<String>',context!);
        TerminationReasonComment = json['TerminationReasonComment'];
        TerminationReasonId = json['TerminationReasonId'];
        Behaviour = JsonConverters.fromJson(json['Behaviour'],'UsageBehaviourEnum',context!);
        CreditKind = JsonConverters.fromJson(json['CreditKind'],'CreditKindEnum',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CompanyId': CompanyId,
        'Id': Id,
        'InvoiceLineTexts': JsonConverters.toJson(InvoiceLineTexts,'List<String>',context!),
        'TerminationReasonComment': TerminationReasonComment,
        'TerminationReasonId': TerminationReasonId,
        'Behaviour': JsonConverters.toJson(Behaviour,'UsageBehaviourEnum',context!),
        'CreditKind': JsonConverters.toJson(CreditKind,'CreditKindEnum',context!)
    };

    createResponse() => CreateUsageTerminationResult();
    getResponseTypeName() => "CreateUsageTerminationResult";
    getTypeName() => "CreateVossUsageTermination";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.bokamera.se', types: <String, TypeInfo> {
    'UsageBehaviourEnum': TypeInfo(TypeOf.Enum, enumValues:UsageBehaviourEnum.values),
    'CreditKindEnum': TypeInfo(TypeOf.Enum, enumValues:CreditKindEnum.values),
    'ProductTypeEnum': TypeInfo(TypeOf.Enum, enumValues:ProductTypeEnum.values),
    'SubscriptionItemTerminationReasonDto': TypeInfo(TypeOf.Class, create:() => SubscriptionItemTerminationReasonDto()),
    'UsageCreditOptionsDto': TypeInfo(TypeOf.Class, create:() => UsageCreditOptionsDto()),
    'CustomerBalanceChangeItemDto': TypeInfo(TypeOf.Class, create:() => CustomerBalanceChangeItemDto()),
    'CustomerBalanceChangeDto': TypeInfo(TypeOf.Class, create:() => CustomerBalanceChangeDto()),
    'List<CustomerBalanceChangeItemDto>': TypeInfo(TypeOf.Class, create:() => <CustomerBalanceChangeItemDto>[]),
    'CreateUsageTerminationResult': TypeInfo(TypeOf.Class, create:() => CreateUsageTerminationResult()),
    'CreateVossUsageTermination': TypeInfo(TypeOf.Class, create:() => CreateVossUsageTermination()),
});