/* Options:
Date: 2026-10-15 22:23:24
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: EndAllLicenses.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

abstract class ICompany
{
    String? CompanyId;
}

class BaseModel implements IConvertible
{
    BaseModel();
    BaseModel.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    getTypeName() => "BaseModel";
    TypeContext? context = _ctx;
}

class Currency extends BaseModel implements IConvertible
{
    // @Required()
    String Name = "";

    // @Required()
    String CurrencySign = "";

    // @Required()
    bool Active;

    DateTime? ModifiedDate;
    // @Required()
    String Id = "";

    Currency({this.Name,this.CurrencySign,this.Active,this.ModifiedDate,this.Id});
    Currency.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Name = json['Name'];
        CurrencySign = json['CurrencySign'];
        Active = json['Active'];
        ModifiedDate = JsonConverters.fromJson(json['ModifiedDate'],'DateTime',context!);
        Id = json['Id'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Name': Name,
        'CurrencySign': CurrencySign,
        'Active': Active,
        'ModifiedDate': JsonConverters.toJson(ModifiedDate,'DateTime',context!),
        'Id': Id
    });

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

class Country extends BaseModel implements IConvertible
{
    // @References(typeof(Currency))
    String CurrencyId = "";

    Currency CurrencyInfo;
    // @Required()
    String Name = "";

    String? Culture;
    String? TimeZone;
    DateTime? ModifiedDate;
    // @Required()
    String Id = "";

    Country({this.CurrencyId,this.CurrencyInfo,this.Name,this.Culture,this.TimeZone,this.ModifiedDate,this.Id});
    Country.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        CurrencyId = json['CurrencyId'];
        CurrencyInfo = JsonConverters.fromJson(json['CurrencyInfo'],'Currency',context!);
        Name = json['Name'];
        Culture = json['Culture'];
        TimeZone = json['TimeZone'];
        ModifiedDate = JsonConverters.fromJson(json['ModifiedDate'],'DateTime',context!);
        Id = json['Id'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'CurrencyId': CurrencyId,
        'CurrencyInfo': JsonConverters.toJson(CurrencyInfo,'Currency',context!),
        'Name': Name,
        'Culture': Culture,
        'TimeZone': TimeZone,
        'ModifiedDate': JsonConverters.toJson(ModifiedDate,'DateTime',context!),
        'Id': Id
    });

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

class LicenseItemsResponse implements IConvertible
{
    int Id = 0;
    String Name = "";
    int AllowedItems = 0;

    LicenseItemsResponse({this.Id,this.Name,this.AllowedItems});
    LicenseItemsResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'AllowedItems': AllowedItems
    };

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

class LicensePriceResponse implements IConvertible
{
    int LicenseTypeId = 0;
    String CountryId = "";
    int Price = 0;
    Country Country;
    int LicensePlanId = 0;

    LicensePriceResponse({this.LicenseTypeId,this.CountryId,this.Price,this.Country,this.LicensePlanId});
    LicensePriceResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        LicenseTypeId = json['LicenseTypeId'];
        CountryId = json['CountryId'];
        Price = json['Price'];
        Country = JsonConverters.fromJson(json['Country'],'Country',context!);
        LicensePlanId = json['LicensePlanId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'LicenseTypeId': LicenseTypeId,
        'CountryId': CountryId,
        'Price': Price,
        'Country': JsonConverters.toJson(Country,'Country',context!),
        'LicensePlanId': LicensePlanId
    };

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

class LicenseTypeQueryResponse implements IConvertible
{
    /**
    * The license type id
    */
    // @ApiMember(Description="The license type id")
    int Id = 0;

    /**
    * The license type name
    */
    // @ApiMember(Description="The license type name")
    String Name = "";

    /**
    * The license type description
    */
    // @ApiMember(Description="The license type description")
    String Description = "";

    /**
    * If the license type is not a standard license but instead an extra license option. An example would be sending newsletter license.
    */
    // @ApiMember(Description="If the license type is not a standard license but instead an extra license option. An example would be sending newsletter license.")
    bool IsExtraLicenseOption;

    /**
    * The period of notice for the license in days.
    */
    // @ApiMember(Description="The period of notice for the license in days.")
    int PeriodOfNoticeDays = 0;

    /**
    * The license items for the license type
    */
    // @ApiMember(Description="The license items for the license type")
    List<LicenseItemsResponse> Items = [];

    /**
    * The license prices in each country for the license type
    */
    // @ApiMember(Description="The license prices in each country for the license type")
    List<LicensePriceResponse> Prices = [];

    LicenseTypeQueryResponse({this.Id,this.Name,this.Description,this.IsExtraLicenseOption,this.PeriodOfNoticeDays,this.Items,this.Prices});
    LicenseTypeQueryResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Name = json['Name'];
        Description = json['Description'];
        IsExtraLicenseOption = json['IsExtraLicenseOption'];
        PeriodOfNoticeDays = json['PeriodOfNoticeDays'];
        Items = JsonConverters.fromJson(json['Items'],'List<LicenseItemsResponse>',context!);
        Prices = JsonConverters.fromJson(json['Prices'],'List<LicensePriceResponse>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'Description': Description,
        'IsExtraLicenseOption': IsExtraLicenseOption,
        'PeriodOfNoticeDays': PeriodOfNoticeDays,
        'Items': JsonConverters.toJson(Items,'List<LicenseItemsResponse>',context!),
        'Prices': JsonConverters.toJson(Prices,'List<LicensePriceResponse>',context!)
    };

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

class ProductGroupResponse implements IConvertible
{
    String Id = "";
    String Name = "";
    String TierId = "";

    ProductGroupResponse({this.Id,this.Name,this.TierId});
    ProductGroupResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'TierId': TierId
    };

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

class TierResponse implements IConvertible
{
    String Id = "";
    String Name = "";
    List<ProductGroupResponse> ProductGroups = [];

    TierResponse({this.Id,this.Name,this.ProductGroups});
    TierResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'ProductGroups': JsonConverters.toJson(ProductGroups,'List<ProductGroupResponse>',context!)
    };

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

class VossSubscriptionResponse implements IConvertible
{
    DateTime SubscriptionBillingPeriodStartDate = DateTime(0);
    DateTime SubscriptionBillingPeriodEndDate = DateTime(0);
    DateTime? BindingPeriodEndDate;
    TierResponse Tier;

    VossSubscriptionResponse({this.SubscriptionBillingPeriodStartDate,this.SubscriptionBillingPeriodEndDate,this.BindingPeriodEndDate,this.Tier});
    VossSubscriptionResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        SubscriptionBillingPeriodStartDate = JsonConverters.fromJson(json['SubscriptionBillingPeriodStartDate'],'DateTime',context!);
        SubscriptionBillingPeriodEndDate = JsonConverters.fromJson(json['SubscriptionBillingPeriodEndDate'],'DateTime',context!);
        BindingPeriodEndDate = JsonConverters.fromJson(json['BindingPeriodEndDate'],'DateTime',context!);
        Tier = JsonConverters.fromJson(json['Tier'],'TierResponse',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'SubscriptionBillingPeriodStartDate': JsonConverters.toJson(SubscriptionBillingPeriodStartDate,'DateTime',context!),
        'SubscriptionBillingPeriodEndDate': JsonConverters.toJson(SubscriptionBillingPeriodEndDate,'DateTime',context!),
        'BindingPeriodEndDate': JsonConverters.toJson(BindingPeriodEndDate,'DateTime',context!),
        'Tier': JsonConverters.toJson(Tier,'TierResponse',context!)
    };

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

class CompanyLicenseQueryResponse implements IConvertible
{
    int Id = 0;
    int TypeId = 0;
    LicenseTypeQueryResponse Type;
    DateTime ValidFrom = DateTime(0);
    DateTime ValidTo = DateTime(0);
    String? VossSubscriptionId;
    VossSubscriptionResponse VossSubscription;
    String MetaData = "";
    bool Active;
    String LicenseStatus = "";
    bool Canceled;
    int? LicensePlanId;
    DateTime Updated = DateTime(0);
    DateTime Created = DateTime(0);

    CompanyLicenseQueryResponse({this.Id,this.TypeId,this.Type,this.ValidFrom,this.ValidTo,this.VossSubscriptionId,this.VossSubscription,this.MetaData,this.Active,this.LicenseStatus,this.Canceled,this.LicensePlanId,this.Updated,this.Created});
    CompanyLicenseQueryResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        TypeId = json['TypeId'];
        Type = JsonConverters.fromJson(json['Type'],'LicenseTypeQueryResponse',context!);
        ValidFrom = JsonConverters.fromJson(json['ValidFrom'],'DateTime',context!);
        ValidTo = JsonConverters.fromJson(json['ValidTo'],'DateTime',context!);
        VossSubscriptionId = json['VossSubscriptionId'];
        VossSubscription = JsonConverters.fromJson(json['VossSubscription'],'VossSubscriptionResponse',context!);
        MetaData = json['MetaData'];
        Active = json['Active'];
        LicenseStatus = json['LicenseStatus'];
        Canceled = json['Canceled'];
        LicensePlanId = json['LicensePlanId'];
        Updated = JsonConverters.fromJson(json['Updated'],'DateTime',context!);
        Created = JsonConverters.fromJson(json['Created'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'TypeId': TypeId,
        'Type': JsonConverters.toJson(Type,'LicenseTypeQueryResponse',context!),
        'ValidFrom': JsonConverters.toJson(ValidFrom,'DateTime',context!),
        'ValidTo': JsonConverters.toJson(ValidTo,'DateTime',context!),
        'VossSubscriptionId': VossSubscriptionId,
        'VossSubscription': JsonConverters.toJson(VossSubscription,'VossSubscriptionResponse',context!),
        'MetaData': MetaData,
        'Active': Active,
        'LicenseStatus': LicenseStatus,
        'Canceled': Canceled,
        'LicensePlanId': LicensePlanId,
        'Updated': JsonConverters.toJson(Updated,'DateTime',context!),
        'Created': JsonConverters.toJson(Created,'DateTime',context!)
    };

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

// @Route("/licenses/company/delete", "POST")
// @ApiResponse(Description="You were unauthorized to call this service", StatusCode=401)
// @ValidateRequest(Validator="IsAuthenticated")
class EndAllLicenses implements IReturn<CompanyLicenseQueryResponse>, ICompany, IConvertible, IPost
{
    /**
    * The company id, if empty will use the company id for the user you are logged in with.
    */
    // @ApiMember(Description="The company id, if empty will use the company id for the user you are logged in with.")
    String? CompanyId;

    /**
    * If true, all licenses and the booking system are terminated today. If false (default), the licenses stay active and are billed until the end of the current billing period, and each license's ValidTo is set to that date.
    */
    // @ApiMember(Description="If true, all licenses and the booking system are terminated today. If false (default), the licenses stay active and are billed until the end of the current billing period, and each license's ValidTo is set to that date.")
    bool Deactivate;

    /**
    * Questionaire with answers from customer why ending license.
    */
    // @ApiMember(Description="Questionaire with answers from customer why ending license.")
    List<Questionnaire> Questionnaire = [];

    EndAllLicenses({this.CompanyId,this.Deactivate,this.Questionnaire});
    EndAllLicenses.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CompanyId = json['CompanyId'];
        Deactivate = json['Deactivate'];
        Questionnaire = JsonConverters.fromJson(json['Questionnaire'],'List<Questionnaire>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CompanyId': CompanyId,
        'Deactivate': Deactivate,
        'Questionnaire': JsonConverters.toJson(Questionnaire,'List<Questionnaire>',context!)
    };

    createResponse() => CompanyLicenseQueryResponse();
    getResponseTypeName() => "CompanyLicenseQueryResponse";
    getTypeName() => "EndAllLicenses";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'testapi.bokamera.se', types: <String, TypeInfo> {
    'ICompany': TypeInfo(TypeOf.Interface),
    'BaseModel': TypeInfo(TypeOf.Class, create:() => BaseModel()),
    'Currency': TypeInfo(TypeOf.Class, create:() => Currency()),
    'Country': TypeInfo(TypeOf.Class, create:() => Country()),
    'LicenseItemsResponse': TypeInfo(TypeOf.Class, create:() => LicenseItemsResponse()),
    'LicensePriceResponse': TypeInfo(TypeOf.Class, create:() => LicensePriceResponse()),
    'LicenseTypeQueryResponse': TypeInfo(TypeOf.Class, create:() => LicenseTypeQueryResponse()),
    'List<LicenseItemsResponse>': TypeInfo(TypeOf.Class, create:() => <LicenseItemsResponse>[]),
    'List<LicensePriceResponse>': TypeInfo(TypeOf.Class, create:() => <LicensePriceResponse>[]),
    'ProductGroupResponse': TypeInfo(TypeOf.Class, create:() => ProductGroupResponse()),
    'TierResponse': TypeInfo(TypeOf.Class, create:() => TierResponse()),
    'List<ProductGroupResponse>': TypeInfo(TypeOf.Class, create:() => <ProductGroupResponse>[]),
    'VossSubscriptionResponse': TypeInfo(TypeOf.Class, create:() => VossSubscriptionResponse()),
    'CompanyLicenseQueryResponse': TypeInfo(TypeOf.Class, create:() => CompanyLicenseQueryResponse()),
    'EndAllLicenses': TypeInfo(TypeOf.Class, create:() => EndAllLicenses()),
    'List<Questionnaire>': TypeInfo(TypeOf.Class, create:() => <Questionnaire>[]),
    'Questionnaire': TypeInfo(TypeOf.Class, create:() => Questionnaire()),
});