/* Options:
Date: 2025-12-06 07:51:06
Version: 8.80
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://business-api.brovs.com

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


library BusinessApi;
import 'package:servicestack/servicestack.dart';

enum StaffRole
{
    Owner,
    Admin,
    Regular,
}

enum BusinessRole
{
    Owner,
    Manager,
    Sales,
    Marketing,
    Other,
}

class BusinessContact implements IConvertible
{
    String? firstName;
    String? lastName;
    String? position;
    String? phone;
    String? email;

    BusinessContact({this.firstName,this.lastName,this.position,this.phone,this.email});
    BusinessContact.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        firstName = json['firstName'];
        lastName = json['lastName'];
        position = json['position'];
        phone = json['phone'];
        email = json['email'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'firstName': firstName,
        'lastName': lastName,
        'position': position,
        'phone': phone,
        'email': email
    };

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

enum PriceMainDish
{
    Value,
    Medium,
    High,
    FineDining,
}

class OpeningHour implements IConvertible
{
    int? openAtHour;
    int? openAtMinute;
    int? closeAtHour;
    int? closeAtMinute;

    OpeningHour({this.openAtHour,this.openAtMinute,this.closeAtHour,this.closeAtMinute});
    OpeningHour.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        openAtHour = json['openAtHour'];
        openAtMinute = json['openAtMinute'];
        closeAtHour = json['closeAtHour'];
        closeAtMinute = json['closeAtMinute'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'openAtHour': openAtHour,
        'openAtMinute': openAtMinute,
        'closeAtHour': closeAtHour,
        'closeAtMinute': closeAtMinute
    };

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

class WeeklyOpeningHours implements IConvertible
{
    OpeningHour? monday;
    OpeningHour? tuesday;
    OpeningHour? wednesday;
    OpeningHour? thursday;
    OpeningHour? friday;
    OpeningHour? saturday;
    OpeningHour? sunday;

    WeeklyOpeningHours({this.monday,this.tuesday,this.wednesday,this.thursday,this.friday,this.saturday,this.sunday});
    WeeklyOpeningHours.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        monday = JsonConverters.fromJson(json['monday'],'OpeningHour',context!);
        tuesday = JsonConverters.fromJson(json['tuesday'],'OpeningHour',context!);
        wednesday = JsonConverters.fromJson(json['wednesday'],'OpeningHour',context!);
        thursday = JsonConverters.fromJson(json['thursday'],'OpeningHour',context!);
        friday = JsonConverters.fromJson(json['friday'],'OpeningHour',context!);
        saturday = JsonConverters.fromJson(json['saturday'],'OpeningHour',context!);
        sunday = JsonConverters.fromJson(json['sunday'],'OpeningHour',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'monday': JsonConverters.toJson(monday,'OpeningHour',context!),
        'tuesday': JsonConverters.toJson(tuesday,'OpeningHour',context!),
        'wednesday': JsonConverters.toJson(wednesday,'OpeningHour',context!),
        'thursday': JsonConverters.toJson(thursday,'OpeningHour',context!),
        'friday': JsonConverters.toJson(friday,'OpeningHour',context!),
        'saturday': JsonConverters.toJson(saturday,'OpeningHour',context!),
        'sunday': JsonConverters.toJson(sunday,'OpeningHour',context!)
    };

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

class OpeningHours implements IConvertible
{
    WeeklyOpeningHours? weekly;

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

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

    Map<String, dynamic> toJson() => {
        'weekly': JsonConverters.toJson(weekly,'WeeklyOpeningHours',context!)
    };

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

enum Locale
{
    EnUs,
    NbNo,
}

class BusinessUserDto implements IConvertible
{
    int? id;
    String? email;
    String? firstName;
    String? lastName;
    String? mobilePhone;
    bool? legalIdentityVerified;
    Locale? locale;

    BusinessUserDto({this.id,this.email,this.firstName,this.lastName,this.mobilePhone,this.legalIdentityVerified,this.locale});
    BusinessUserDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        email = json['email'];
        firstName = json['firstName'];
        lastName = json['lastName'];
        mobilePhone = json['mobilePhone'];
        legalIdentityVerified = json['legalIdentityVerified'];
        locale = JsonConverters.fromJson(json['locale'],'Locale',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'email': email,
        'firstName': firstName,
        'lastName': lastName,
        'mobilePhone': mobilePhone,
        'legalIdentityVerified': legalIdentityVerified,
        'locale': JsonConverters.toJson(locale,'Locale',context!)
    };

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

class PriceMainDishDto implements IConvertible
{
    String? title;
    PriceMainDish? slug;

    PriceMainDishDto({this.title,this.slug});
    PriceMainDishDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        title = json['title'];
        slug = JsonConverters.fromJson(json['slug'],'PriceMainDish',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'title': title,
        'slug': JsonConverters.toJson(slug,'PriceMainDish',context!)
    };

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

enum BusinessUserStatus
{
    SignInOrUp,
    MustCompleteConsumerSignup,
    MustProvideEmailAddress,
    MustConfirmEmailAddress,
    MustAcceptTermsOfService,
    Ready,
}

class StaffInvitationDto implements IConvertible
{
    int? id;
    int? userId;
    int? placeId;
    String? placeGuid;
    String? inviteKey;
    int? businessId;
    String? firstName;
    String? lastName;
    String? placeName;
    String? businessName;
    StaffRole? role;
    BusinessRole? businessRole;
    DateTime? createdAt;
    DateTime? updatedAt;

    StaffInvitationDto({this.id,this.userId,this.placeId,this.placeGuid,this.inviteKey,this.businessId,this.firstName,this.lastName,this.placeName,this.businessName,this.role,this.businessRole,this.createdAt,this.updatedAt});
    StaffInvitationDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        userId = json['userId'];
        placeId = json['placeId'];
        placeGuid = json['placeGuid'];
        inviteKey = json['inviteKey'];
        businessId = json['businessId'];
        firstName = json['firstName'];
        lastName = json['lastName'];
        placeName = json['placeName'];
        businessName = json['businessName'];
        role = JsonConverters.fromJson(json['role'],'StaffRole',context!);
        businessRole = JsonConverters.fromJson(json['businessRole'],'BusinessRole',context!);
        createdAt = JsonConverters.fromJson(json['createdAt'],'DateTime',context!);
        updatedAt = JsonConverters.fromJson(json['updatedAt'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'userId': userId,
        'placeId': placeId,
        'placeGuid': placeGuid,
        'inviteKey': inviteKey,
        'businessId': businessId,
        'firstName': firstName,
        'lastName': lastName,
        'placeName': placeName,
        'businessName': businessName,
        'role': JsonConverters.toJson(role,'StaffRole',context!),
        'businessRole': JsonConverters.toJson(businessRole,'BusinessRole',context!),
        'createdAt': JsonConverters.toJson(createdAt,'DateTime',context!),
        'updatedAt': JsonConverters.toJson(updatedAt,'DateTime',context!)
    };

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

class BusinessDto implements IConvertible
{
    int? id;
    String? name;
    String? organizationNumber;
    String? streetAddress;
    String? postalCode;
    String? city;
    String? country;
    BusinessContact? contact;

    BusinessDto({this.id,this.name,this.organizationNumber,this.streetAddress,this.postalCode,this.city,this.country,this.contact});
    BusinessDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        organizationNumber = json['organizationNumber'];
        streetAddress = json['streetAddress'];
        postalCode = json['postalCode'];
        city = json['city'];
        country = json['country'];
        contact = JsonConverters.fromJson(json['contact'],'BusinessContact',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'organizationNumber': organizationNumber,
        'streetAddress': streetAddress,
        'postalCode': postalCode,
        'city': city,
        'country': country,
        'contact': JsonConverters.toJson(contact,'BusinessContact',context!)
    };

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

enum PlaceType
{
    Mall,
    Regular,
}

class PlaceContact implements IConvertible
{
    String? phone;
    String? email;
    String? website;
    String? webShop;

    PlaceContact({this.phone,this.email,this.website,this.webShop});
    PlaceContact.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        phone = json['phone'];
        email = json['email'];
        website = json['website'];
        webShop = json['webShop'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'phone': phone,
        'email': email,
        'website': website,
        'webShop': webShop
    };

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

class PlaceAddress implements IConvertible
{
    String? street;
    String? postalCode;
    String? region;
    String? countryCode;

    PlaceAddress({this.street,this.postalCode,this.region,this.countryCode});
    PlaceAddress.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        street = json['street'];
        postalCode = json['postalCode'];
        region = json['region'];
        countryCode = json['countryCode'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'street': street,
        'postalCode': postalCode,
        'region': region,
        'countryCode': countryCode
    };

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

class TimeZoneDto implements IConvertible
{
    Duration? baseUtcOffset;
    String? daylightName;
    String? displayName;
    String? id;
    String? standardName;
    bool? supportsDaylightSavingTime;

    TimeZoneDto({this.baseUtcOffset,this.daylightName,this.displayName,this.id,this.standardName,this.supportsDaylightSavingTime});
    TimeZoneDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        baseUtcOffset = JsonConverters.fromJson(json['baseUtcOffset'],'Duration',context!);
        daylightName = json['daylightName'];
        displayName = json['displayName'];
        id = json['id'];
        standardName = json['standardName'];
        supportsDaylightSavingTime = json['supportsDaylightSavingTime'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'baseUtcOffset': JsonConverters.toJson(baseUtcOffset,'Duration',context!),
        'daylightName': daylightName,
        'displayName': displayName,
        'id': id,
        'standardName': standardName,
        'supportsDaylightSavingTime': supportsDaylightSavingTime
    };

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

class MallOtherServiceDto implements IConvertible
{
    int? id;
    String? serviceName;
    String? floor;

    MallOtherServiceDto({this.id,this.serviceName,this.floor});
    MallOtherServiceDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'id': id,
        'serviceName': serviceName,
        'floor': floor
    };

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

class PlaceBasicDto implements IConvertible
{
    int? id;
    String? guid;
    String? name;
    int? businessId;
    double? longitude;
    double? latitude;
    bool? claimed;
    String? organizationNumber;
    String? countryCode;
    String? overview;
    OpeningHours? openingHours;
    PlaceType? placeType;
    PlaceContact? contact;
    PlaceAddress? address;
    bool? wheelChairAccessible;
    bool? wifi;
    bool? outdoorSeating;
    bool? saveFoodAndMoney;
    TimeZoneDto? timeZoneDto;
    PriceMainDishDto? priceMainDish;
    List<MallOtherServiceDto>? otherServices = [];
    String? floor;

    PlaceBasicDto({this.id,this.guid,this.name,this.businessId,this.longitude,this.latitude,this.claimed,this.organizationNumber,this.countryCode,this.overview,this.openingHours,this.placeType,this.contact,this.address,this.wheelChairAccessible,this.wifi,this.outdoorSeating,this.saveFoodAndMoney,this.timeZoneDto,this.priceMainDish,this.otherServices,this.floor});
    PlaceBasicDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        guid = json['guid'];
        name = json['name'];
        businessId = json['businessId'];
        longitude = JsonConverters.toDouble(json['longitude']);
        latitude = JsonConverters.toDouble(json['latitude']);
        claimed = json['claimed'];
        organizationNumber = json['organizationNumber'];
        countryCode = json['countryCode'];
        overview = json['overview'];
        openingHours = JsonConverters.fromJson(json['openingHours'],'OpeningHours',context!);
        placeType = JsonConverters.fromJson(json['placeType'],'PlaceType',context!);
        contact = JsonConverters.fromJson(json['contact'],'PlaceContact',context!);
        address = JsonConverters.fromJson(json['address'],'PlaceAddress',context!);
        wheelChairAccessible = json['wheelChairAccessible'];
        wifi = json['wifi'];
        outdoorSeating = json['outdoorSeating'];
        saveFoodAndMoney = json['saveFoodAndMoney'];
        timeZoneDto = JsonConverters.fromJson(json['timeZoneDto'],'TimeZoneDto',context!);
        priceMainDish = JsonConverters.fromJson(json['priceMainDish'],'PriceMainDishDto',context!);
        otherServices = JsonConverters.fromJson(json['otherServices'],'List<MallOtherServiceDto>',context!);
        floor = json['floor'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'guid': guid,
        'name': name,
        'businessId': businessId,
        'longitude': longitude,
        'latitude': latitude,
        'claimed': claimed,
        'organizationNumber': organizationNumber,
        'countryCode': countryCode,
        'overview': overview,
        'openingHours': JsonConverters.toJson(openingHours,'OpeningHours',context!),
        'placeType': JsonConverters.toJson(placeType,'PlaceType',context!),
        'contact': JsonConverters.toJson(contact,'PlaceContact',context!),
        'address': JsonConverters.toJson(address,'PlaceAddress',context!),
        'wheelChairAccessible': wheelChairAccessible,
        'wifi': wifi,
        'outdoorSeating': outdoorSeating,
        'saveFoodAndMoney': saveFoodAndMoney,
        'timeZoneDto': JsonConverters.toJson(timeZoneDto,'TimeZoneDto',context!),
        'priceMainDish': JsonConverters.toJson(priceMainDish,'PriceMainDishDto',context!),
        'otherServices': JsonConverters.toJson(otherServices,'List<MallOtherServiceDto>',context!),
        'floor': floor
    };

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

class UserStatusResponse implements IConvertible
{
    BusinessUserStatus? status;
    BusinessUserDto? userDto;
    List<StaffInvitationDto>? invitations = [];
    List<String>? roles = [];
    List<BusinessDto>? businesses = [];
    List<PlaceBasicDto>? places = [];

    UserStatusResponse({this.status,this.userDto,this.invitations,this.roles,this.businesses,this.places});
    UserStatusResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        status = JsonConverters.fromJson(json['status'],'BusinessUserStatus',context!);
        userDto = JsonConverters.fromJson(json['userDto'],'BusinessUserDto',context!);
        invitations = JsonConverters.fromJson(json['invitations'],'List<StaffInvitationDto>',context!);
        roles = JsonConverters.fromJson(json['roles'],'List<String>',context!);
        businesses = JsonConverters.fromJson(json['businesses'],'List<BusinessDto>',context!);
        places = JsonConverters.fromJson(json['places'],'List<PlaceBasicDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'status': JsonConverters.toJson(status,'BusinessUserStatus',context!),
        'userDto': JsonConverters.toJson(userDto,'BusinessUserDto',context!),
        'invitations': JsonConverters.toJson(invitations,'List<StaffInvitationDto>',context!),
        'roles': JsonConverters.toJson(roles,'List<String>',context!),
        'businesses': JsonConverters.toJson(businesses,'List<BusinessDto>',context!),
        'places': JsonConverters.toJson(places,'List<PlaceBasicDto>',context!)
    };

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

// @Route("/user/status", "GET")
class UserStatusRequest implements IReturn<UserStatusResponse>, IGet, IConvertible
{
    UserStatusRequest();
    UserStatusRequest.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    createResponse() => UserStatusResponse();
    getResponseTypeName() => "UserStatusResponse";
    getTypeName() => "UserStatusRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'BusinessApi', types: <String, TypeInfo> {
    'StaffRole': TypeInfo(TypeOf.Enum, enumValues:StaffRole.values),
    'BusinessRole': TypeInfo(TypeOf.Enum, enumValues:BusinessRole.values),
    'BusinessContact': TypeInfo(TypeOf.Class, create:() => BusinessContact()),
    'PriceMainDish': TypeInfo(TypeOf.Enum, enumValues:PriceMainDish.values),
    'OpeningHour': TypeInfo(TypeOf.Class, create:() => OpeningHour()),
    'WeeklyOpeningHours': TypeInfo(TypeOf.Class, create:() => WeeklyOpeningHours()),
    'OpeningHours': TypeInfo(TypeOf.Class, create:() => OpeningHours()),
    'Locale': TypeInfo(TypeOf.Enum, enumValues:Locale.values),
    'BusinessUserDto': TypeInfo(TypeOf.Class, create:() => BusinessUserDto()),
    'PriceMainDishDto': TypeInfo(TypeOf.Class, create:() => PriceMainDishDto()),
    'BusinessUserStatus': TypeInfo(TypeOf.Enum, enumValues:BusinessUserStatus.values),
    'StaffInvitationDto': TypeInfo(TypeOf.Class, create:() => StaffInvitationDto()),
    'BusinessDto': TypeInfo(TypeOf.Class, create:() => BusinessDto()),
    'PlaceType': TypeInfo(TypeOf.Enum, enumValues:PlaceType.values),
    'PlaceContact': TypeInfo(TypeOf.Class, create:() => PlaceContact()),
    'PlaceAddress': TypeInfo(TypeOf.Class, create:() => PlaceAddress()),
    'TimeZoneDto': TypeInfo(TypeOf.Class, create:() => TimeZoneDto()),
    'MallOtherServiceDto': TypeInfo(TypeOf.Class, create:() => MallOtherServiceDto()),
    'PlaceBasicDto': TypeInfo(TypeOf.Class, create:() => PlaceBasicDto()),
    'List<MallOtherServiceDto>': TypeInfo(TypeOf.Class, create:() => <MallOtherServiceDto>[]),
    'UserStatusResponse': TypeInfo(TypeOf.Class, create:() => UserStatusResponse()),
    'List<StaffInvitationDto>': TypeInfo(TypeOf.Class, create:() => <StaffInvitationDto>[]),
    'List<BusinessDto>': TypeInfo(TypeOf.Class, create:() => <BusinessDto>[]),
    'List<PlaceBasicDto>': TypeInfo(TypeOf.Class, create:() => <PlaceBasicDto>[]),
    'UserStatusRequest': TypeInfo(TypeOf.Class, create:() => UserStatusRequest()),
});