/* Options:
Date: 2024-12-23 12:13:05
Version: 8.0
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://consumer-api.brovs.com

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


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

enum Parking
{
    StreetParking,
    ParkingGarageNearby,
}

enum PaymentOption
{
    Visa,
    MasterCard,
    AmericanExpress,
    Diners,
    Vipps,
}

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

enum DayOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
}

class OpenAtTimeDto implements IConvertible
{
    DayOfWeek? weekDay;
    int? hour;
    int? minute;

    OpenAtTimeDto({this.weekDay,this.hour,this.minute});
    OpenAtTimeDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'weekDay': JsonConverters.toJson(weekDay,'DayOfWeek',context!),
        'hour': hour,
        'minute': minute
    };

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

class QueryFilterDto implements IConvertible
{
    String? term;
    String? placeGuid;
    String? adMessageGuid;
    List<String>? categoryAbsoluteSlugs;
    List<String>? barSpecialitySlugs;
    List<String>? barTypeSlugs;
    List<String>? brandNames;
    List<String>? cuisineSlugs;
    List<String>? mealTypeSlugs;
    List<Parking>? parking;
    List<PaymentOption>? paymentOptions;
    List<PriceMainDish>? priceMainDishes;
    List<String>? eatingSuitabilitySlugs;
    List<String>? takeAwaySlugs;
    List<String>? wearPriceProfileSlugs;
    bool? wheelChairAccessible;
    bool? wifi;
    bool? outdoorSeating;
    bool? saveFoodAndMoney;
    OpenAtTimeDto? openAt;

    QueryFilterDto({this.term,this.placeGuid,this.adMessageGuid,this.categoryAbsoluteSlugs,this.barSpecialitySlugs,this.barTypeSlugs,this.brandNames,this.cuisineSlugs,this.mealTypeSlugs,this.parking,this.paymentOptions,this.priceMainDishes,this.eatingSuitabilitySlugs,this.takeAwaySlugs,this.wearPriceProfileSlugs,this.wheelChairAccessible,this.wifi,this.outdoorSeating,this.saveFoodAndMoney,this.openAt});
    QueryFilterDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        term = json['term'];
        placeGuid = json['placeGuid'];
        adMessageGuid = json['adMessageGuid'];
        categoryAbsoluteSlugs = JsonConverters.fromJson(json['categoryAbsoluteSlugs'],'List<String>',context!);
        barSpecialitySlugs = JsonConverters.fromJson(json['barSpecialitySlugs'],'List<String>',context!);
        barTypeSlugs = JsonConverters.fromJson(json['barTypeSlugs'],'List<String>',context!);
        brandNames = JsonConverters.fromJson(json['brandNames'],'List<String>',context!);
        cuisineSlugs = JsonConverters.fromJson(json['cuisineSlugs'],'List<String>',context!);
        mealTypeSlugs = JsonConverters.fromJson(json['mealTypeSlugs'],'List<String>',context!);
        parking = JsonConverters.fromJson(json['parking'],'List<Parking>',context!);
        paymentOptions = JsonConverters.fromJson(json['paymentOptions'],'List<PaymentOption>',context!);
        priceMainDishes = JsonConverters.fromJson(json['priceMainDishes'],'List<PriceMainDish>',context!);
        eatingSuitabilitySlugs = JsonConverters.fromJson(json['eatingSuitabilitySlugs'],'List<String>',context!);
        takeAwaySlugs = JsonConverters.fromJson(json['takeAwaySlugs'],'List<String>',context!);
        wearPriceProfileSlugs = JsonConverters.fromJson(json['wearPriceProfileSlugs'],'List<String>',context!);
        wheelChairAccessible = json['wheelChairAccessible'];
        wifi = json['wifi'];
        outdoorSeating = json['outdoorSeating'];
        saveFoodAndMoney = json['saveFoodAndMoney'];
        openAt = JsonConverters.fromJson(json['openAt'],'OpenAtTimeDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'term': term,
        'placeGuid': placeGuid,
        'adMessageGuid': adMessageGuid,
        'categoryAbsoluteSlugs': JsonConverters.toJson(categoryAbsoluteSlugs,'List<String>',context!),
        'barSpecialitySlugs': JsonConverters.toJson(barSpecialitySlugs,'List<String>',context!),
        'barTypeSlugs': JsonConverters.toJson(barTypeSlugs,'List<String>',context!),
        'brandNames': JsonConverters.toJson(brandNames,'List<String>',context!),
        'cuisineSlugs': JsonConverters.toJson(cuisineSlugs,'List<String>',context!),
        'mealTypeSlugs': JsonConverters.toJson(mealTypeSlugs,'List<String>',context!),
        'parking': JsonConverters.toJson(parking,'List<Parking>',context!),
        'paymentOptions': JsonConverters.toJson(paymentOptions,'List<PaymentOption>',context!),
        'priceMainDishes': JsonConverters.toJson(priceMainDishes,'List<PriceMainDish>',context!),
        'eatingSuitabilitySlugs': JsonConverters.toJson(eatingSuitabilitySlugs,'List<String>',context!),
        'takeAwaySlugs': JsonConverters.toJson(takeAwaySlugs,'List<String>',context!),
        'wearPriceProfileSlugs': JsonConverters.toJson(wearPriceProfileSlugs,'List<String>',context!),
        'wheelChairAccessible': wheelChairAccessible,
        'wifi': wifi,
        'outdoorSeating': outdoorSeating,
        'saveFoodAndMoney': saveFoodAndMoney,
        'openAt': JsonConverters.toJson(openAt,'OpenAtTimeDto',context!)
    };

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

abstract class ICacheable
{
    int? cacheVersion;
}

class MapBoundsDto implements IConvertible
{
    double? north;
    double? south;
    double? east;
    double? west;
    int? clusterZoomLevel;

    MapBoundsDto({this.north,this.south,this.east,this.west,this.clusterZoomLevel});
    MapBoundsDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        north = JsonConverters.toDouble(json['north']);
        south = JsonConverters.toDouble(json['south']);
        east = JsonConverters.toDouble(json['east']);
        west = JsonConverters.toDouble(json['west']);
        clusterZoomLevel = json['clusterZoomLevel'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'north': north,
        'south': south,
        'east': east,
        'west': west,
        'clusterZoomLevel': clusterZoomLevel
    };

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

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;
}

class CategoryTreeDto implements IConvertible
{
    String? name;
    String? slug;
    String? absoluteSlug;
    String? imageUrl;
    String? allImageUrl;
    String? iconImageUrl;
    int? position;
    List<CategoryTreeDto>? children;

    CategoryTreeDto({this.name,this.slug,this.absoluteSlug,this.imageUrl,this.allImageUrl,this.iconImageUrl,this.position,this.children});
    CategoryTreeDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        slug = json['slug'];
        absoluteSlug = json['absoluteSlug'];
        imageUrl = json['imageUrl'];
        allImageUrl = json['allImageUrl'];
        iconImageUrl = json['iconImageUrl'];
        position = json['position'];
        children = JsonConverters.fromJson(json['children'],'List<CategoryTreeDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'slug': slug,
        'absoluteSlug': absoluteSlug,
        'imageUrl': imageUrl,
        'allImageUrl': allImageUrl,
        'iconImageUrl': iconImageUrl,
        'position': position,
        'children': JsonConverters.toJson(children,'List<CategoryTreeDto>',context!)
    };

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

enum FeatureType
{
    BarSpeciality,
    BarType,
    Cuisine,
    SaveFoodAndMoney,
    MealType,
    Menu,
    OutdoorSeating,
    Parking,
    PaymentOptions,
    PriceMainDish,
    SubCategories,
    SubCategoriesAndBrands,
    EatingSuitabilities,
    TakeAway,
    WearPriceProfile,
    WheelChairAccessible,
    Wifi,
    WebShop,
    Filtering,
}

class IndividualFeatureDataDto implements IConvertible
{
    FeatureType? slug;
    String? label;

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

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

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

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

class BarSpecialityDto implements IConvertible
{
    String? slug;
    String? title;

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

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

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

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

class BarTypeDto implements IConvertible
{
    String? slug;
    String? title;

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

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

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

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

class BrandDto implements IConvertible
{
    String? name;

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

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

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

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

class PlaceCustomBrandDto implements IConvertible
{
    String? name;

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

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

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

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

class PlaceSelectedBrandDto implements IConvertible
{
    BrandDto? brand;
    List<String>? categoryAbsoluteSlugs;
    PlaceCustomBrandDto? placeCustomBrand;

    PlaceSelectedBrandDto({this.brand,this.categoryAbsoluteSlugs,this.placeCustomBrand});
    PlaceSelectedBrandDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        brand = JsonConverters.fromJson(json['brand'],'BrandDto',context!);
        categoryAbsoluteSlugs = JsonConverters.fromJson(json['categoryAbsoluteSlugs'],'List<String>',context!);
        placeCustomBrand = JsonConverters.fromJson(json['placeCustomBrand'],'PlaceCustomBrandDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'brand': JsonConverters.toJson(brand,'BrandDto',context!),
        'categoryAbsoluteSlugs': JsonConverters.toJson(categoryAbsoluteSlugs,'List<String>',context!),
        'placeCustomBrand': JsonConverters.toJson(placeCustomBrand,'PlaceCustomBrandDto',context!)
    };

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

class CuisineDto implements IConvertible
{
    String? label;
    String? slug;

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

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

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

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

class MealTypeDto implements IConvertible
{
    String? label;
    String? slug;

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

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

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

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

class ParkingDto implements IConvertible
{
    String? label;
    Parking? slug;

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

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

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

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

class PaymentOptionDto implements IConvertible
{
    String? label;
    PaymentOption? slug;

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

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

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

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

class EatingSuitabilityDto implements IConvertible
{
    String? label;
    String? slug;

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

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

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

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

class TakeAwayDto implements IConvertible
{
    String? label;
    String? slug;

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

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

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

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

class WearPriceProfileDto implements IConvertible
{
    String? slug;
    String? label;

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

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

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

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

class MenuDto implements IConvertible
{
    String? name;
    String? url;
    int? position;

    MenuDto({this.name,this.url,this.position});
    MenuDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'name': name,
        'url': url,
        'position': position
    };

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

class ImageUrls implements IConvertible
{
    String? preview;
    String? small;
    String? medium;
    String? large;

    ImageUrls({this.preview,this.small,this.medium,this.large});
    ImageUrls.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        preview = json['preview'];
        small = json['small'];
        medium = json['medium'];
        large = json['large'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'preview': preview,
        'small': small,
        'medium': medium,
        'large': large
    };

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

enum PlaceType
{
    Mall,
    Regular,
}

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;
}

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 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 PlaceBasicDto implements IConvertible
{
    int? id;
    String? guid;
    String? overview;
    String? name;
    double? longitude;
    double? latitude;
    bool? claimed;
    String? organizationNumber;
    String? countryCode;
    OpeningHours? openingHours;
    bool? wheelchairAccessible;
    bool? wifi;
    bool? outdoorSeating;
    bool? saveFoodAndMoney;
    PlaceType? placeType;
    PriceMainDishDto? priceMainDish;
    TimeZoneDto? timeZoneDto;
    int? businessId;
    PlaceContact? contact;
    PlaceAddress? address;
    List<CategoryTreeDto>? categories;
    ImageUrls? logoUrl;
    ImageUrls? imageUrl;
    List<WearPriceProfileDto>? wearPriceProfiles;
    List<PlaceSelectedBrandDto>? brands;
    String? floor;

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

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

    Map<String, dynamic> toJson() => {
        'id': id,
        'guid': guid,
        'overview': overview,
        'name': name,
        'longitude': longitude,
        'latitude': latitude,
        'claimed': claimed,
        'organizationNumber': organizationNumber,
        'countryCode': countryCode,
        'openingHours': JsonConverters.toJson(openingHours,'OpeningHours',context!),
        'wheelchairAccessible': wheelchairAccessible,
        'wifi': wifi,
        'outdoorSeating': outdoorSeating,
        'saveFoodAndMoney': saveFoodAndMoney,
        'placeType': JsonConverters.toJson(placeType,'PlaceType',context!),
        'priceMainDish': JsonConverters.toJson(priceMainDish,'PriceMainDishDto',context!),
        'timeZoneDto': JsonConverters.toJson(timeZoneDto,'TimeZoneDto',context!),
        'businessId': businessId,
        'contact': JsonConverters.toJson(contact,'PlaceContact',context!),
        'address': JsonConverters.toJson(address,'PlaceAddress',context!),
        'categories': JsonConverters.toJson(categories,'List<CategoryTreeDto>',context!),
        'logoUrl': JsonConverters.toJson(logoUrl,'ImageUrls',context!),
        'imageUrl': JsonConverters.toJson(imageUrl,'ImageUrls',context!),
        'wearPriceProfiles': JsonConverters.toJson(wearPriceProfiles,'List<WearPriceProfileDto>',context!),
        'brands': JsonConverters.toJson(brands,'List<PlaceSelectedBrandDto>',context!),
        'floor': floor
    };

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

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

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

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

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

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

class PlaceDto implements IConvertible
{
    int? id;
    String? guid;
    String? overview;
    String? name;
    double? longitude;
    double? latitude;
    bool? claimed;
    String? organizationNumber;
    String? countryCode;
    String? placeState;
    int? followersCount;
    OpeningHours? openingHours;
    List<CategoryTreeDto>? categories;
    List<IndividualFeatureDataDto>? featureData;
    List<BarSpecialityDto>? barSpecialities;
    List<BarTypeDto>? barTypes;
    List<PlaceSelectedBrandDto>? brands;
    List<CuisineDto>? cuisines;
    List<MealTypeDto>? mealTypes;
    List<ParkingDto>? parking;
    List<PaymentOptionDto>? paymentOptions;
    List<EatingSuitabilityDto>? eatingSuitabilities;
    List<TakeAwayDto>? takeAways;
    List<WearPriceProfileDto>? wearPriceProfiles;
    List<MenuDto>? menus;
    ImageUrls? logoUrl;
    ImageUrls? imageUrl;
    bool? wheelchairAccessible;
    bool? wifi;
    bool? outdoorSeating;
    bool? saveFoodAndMoney;
    PlaceType? placeType;
    PlaceBasicDto? mall;
    PriceMainDishDto? priceMainDish;
    List<PlaceBasicDto>? places;
    List<MallOtherServiceDto>? otherServices;
    String? floor;
    TimeZoneDto? timeZoneDto;
    int? businessId;
    PlaceContact? contact;
    PlaceAddress? address;

    PlaceDto({this.id,this.guid,this.overview,this.name,this.longitude,this.latitude,this.claimed,this.organizationNumber,this.countryCode,this.placeState,this.followersCount,this.openingHours,this.categories,this.featureData,this.barSpecialities,this.barTypes,this.brands,this.cuisines,this.mealTypes,this.parking,this.paymentOptions,this.eatingSuitabilities,this.takeAways,this.wearPriceProfiles,this.menus,this.logoUrl,this.imageUrl,this.wheelchairAccessible,this.wifi,this.outdoorSeating,this.saveFoodAndMoney,this.placeType,this.mall,this.priceMainDish,this.places,this.otherServices,this.floor,this.timeZoneDto,this.businessId,this.contact,this.address});
    PlaceDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        guid = json['guid'];
        overview = json['overview'];
        name = json['name'];
        longitude = JsonConverters.toDouble(json['longitude']);
        latitude = JsonConverters.toDouble(json['latitude']);
        claimed = json['claimed'];
        organizationNumber = json['organizationNumber'];
        countryCode = json['countryCode'];
        placeState = json['placeState'];
        followersCount = json['followersCount'];
        openingHours = JsonConverters.fromJson(json['openingHours'],'OpeningHours',context!);
        categories = JsonConverters.fromJson(json['categories'],'List<CategoryTreeDto>',context!);
        featureData = JsonConverters.fromJson(json['featureData'],'List<IndividualFeatureDataDto>',context!);
        barSpecialities = JsonConverters.fromJson(json['barSpecialities'],'List<BarSpecialityDto>',context!);
        barTypes = JsonConverters.fromJson(json['barTypes'],'List<BarTypeDto>',context!);
        brands = JsonConverters.fromJson(json['brands'],'List<PlaceSelectedBrandDto>',context!);
        cuisines = JsonConverters.fromJson(json['cuisines'],'List<CuisineDto>',context!);
        mealTypes = JsonConverters.fromJson(json['mealTypes'],'List<MealTypeDto>',context!);
        parking = JsonConverters.fromJson(json['parking'],'List<ParkingDto>',context!);
        paymentOptions = JsonConverters.fromJson(json['paymentOptions'],'List<PaymentOptionDto>',context!);
        eatingSuitabilities = JsonConverters.fromJson(json['eatingSuitabilities'],'List<EatingSuitabilityDto>',context!);
        takeAways = JsonConverters.fromJson(json['takeAways'],'List<TakeAwayDto>',context!);
        wearPriceProfiles = JsonConverters.fromJson(json['wearPriceProfiles'],'List<WearPriceProfileDto>',context!);
        menus = JsonConverters.fromJson(json['menus'],'List<MenuDto>',context!);
        logoUrl = JsonConverters.fromJson(json['logoUrl'],'ImageUrls',context!);
        imageUrl = JsonConverters.fromJson(json['imageUrl'],'ImageUrls',context!);
        wheelchairAccessible = json['wheelchairAccessible'];
        wifi = json['wifi'];
        outdoorSeating = json['outdoorSeating'];
        saveFoodAndMoney = json['saveFoodAndMoney'];
        placeType = JsonConverters.fromJson(json['placeType'],'PlaceType',context!);
        mall = JsonConverters.fromJson(json['mall'],'PlaceBasicDto',context!);
        priceMainDish = JsonConverters.fromJson(json['priceMainDish'],'PriceMainDishDto',context!);
        places = JsonConverters.fromJson(json['places'],'List<PlaceBasicDto>',context!);
        otherServices = JsonConverters.fromJson(json['otherServices'],'List<MallOtherServiceDto>',context!);
        floor = json['floor'];
        timeZoneDto = JsonConverters.fromJson(json['timeZoneDto'],'TimeZoneDto',context!);
        businessId = json['businessId'];
        contact = JsonConverters.fromJson(json['contact'],'PlaceContact',context!);
        address = JsonConverters.fromJson(json['address'],'PlaceAddress',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'guid': guid,
        'overview': overview,
        'name': name,
        'longitude': longitude,
        'latitude': latitude,
        'claimed': claimed,
        'organizationNumber': organizationNumber,
        'countryCode': countryCode,
        'placeState': placeState,
        'followersCount': followersCount,
        'openingHours': JsonConverters.toJson(openingHours,'OpeningHours',context!),
        'categories': JsonConverters.toJson(categories,'List<CategoryTreeDto>',context!),
        'featureData': JsonConverters.toJson(featureData,'List<IndividualFeatureDataDto>',context!),
        'barSpecialities': JsonConverters.toJson(barSpecialities,'List<BarSpecialityDto>',context!),
        'barTypes': JsonConverters.toJson(barTypes,'List<BarTypeDto>',context!),
        'brands': JsonConverters.toJson(brands,'List<PlaceSelectedBrandDto>',context!),
        'cuisines': JsonConverters.toJson(cuisines,'List<CuisineDto>',context!),
        'mealTypes': JsonConverters.toJson(mealTypes,'List<MealTypeDto>',context!),
        'parking': JsonConverters.toJson(parking,'List<ParkingDto>',context!),
        'paymentOptions': JsonConverters.toJson(paymentOptions,'List<PaymentOptionDto>',context!),
        'eatingSuitabilities': JsonConverters.toJson(eatingSuitabilities,'List<EatingSuitabilityDto>',context!),
        'takeAways': JsonConverters.toJson(takeAways,'List<TakeAwayDto>',context!),
        'wearPriceProfiles': JsonConverters.toJson(wearPriceProfiles,'List<WearPriceProfileDto>',context!),
        'menus': JsonConverters.toJson(menus,'List<MenuDto>',context!),
        'logoUrl': JsonConverters.toJson(logoUrl,'ImageUrls',context!),
        'imageUrl': JsonConverters.toJson(imageUrl,'ImageUrls',context!),
        'wheelchairAccessible': wheelchairAccessible,
        'wifi': wifi,
        'outdoorSeating': outdoorSeating,
        'saveFoodAndMoney': saveFoodAndMoney,
        'placeType': JsonConverters.toJson(placeType,'PlaceType',context!),
        'mall': JsonConverters.toJson(mall,'PlaceBasicDto',context!),
        'priceMainDish': JsonConverters.toJson(priceMainDish,'PriceMainDishDto',context!),
        'places': JsonConverters.toJson(places,'List<PlaceBasicDto>',context!),
        'otherServices': JsonConverters.toJson(otherServices,'List<MallOtherServiceDto>',context!),
        'floor': floor,
        'timeZoneDto': JsonConverters.toJson(timeZoneDto,'TimeZoneDto',context!),
        'businessId': businessId,
        'contact': JsonConverters.toJson(contact,'PlaceContact',context!),
        'address': JsonConverters.toJson(address,'PlaceAddress',context!)
    };

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

enum CategoryFacetTreeType
{
    Parent,
    Selected,
    Available,
}

class CategoryFacetTreeDto implements IConvertible
{
    String? name;
    String? slug;
    String? absoluteSlug;
    List<FeatureType>? featureTypes;
    CategoryFacetTreeType? type;
    int? count;
    String? imageUrl;
    String? allImageUrl;
    String? iconImageUrl;
    int? position;
    List<CategoryFacetTreeDto>? children;

    CategoryFacetTreeDto({this.name,this.slug,this.absoluteSlug,this.featureTypes,this.type,this.count,this.imageUrl,this.allImageUrl,this.iconImageUrl,this.position,this.children});
    CategoryFacetTreeDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        slug = json['slug'];
        absoluteSlug = json['absoluteSlug'];
        featureTypes = JsonConverters.fromJson(json['featureTypes'],'List<FeatureType>',context!);
        type = JsonConverters.fromJson(json['type'],'CategoryFacetTreeType',context!);
        count = json['count'];
        imageUrl = json['imageUrl'];
        allImageUrl = json['allImageUrl'];
        iconImageUrl = json['iconImageUrl'];
        position = json['position'];
        children = JsonConverters.fromJson(json['children'],'List<CategoryFacetTreeDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'slug': slug,
        'absoluteSlug': absoluteSlug,
        'featureTypes': JsonConverters.toJson(featureTypes,'List<FeatureType>',context!),
        'type': JsonConverters.toJson(type,'CategoryFacetTreeType',context!),
        'count': count,
        'imageUrl': imageUrl,
        'allImageUrl': allImageUrl,
        'iconImageUrl': iconImageUrl,
        'position': position,
        'children': JsonConverters.toJson(children,'List<CategoryFacetTreeDto>',context!)
    };

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

class FindBoundedMapPinCluster implements IConvertible
{
    int? count;
    double? latitude;
    double? longitude;

    FindBoundedMapPinCluster({this.count,this.latitude,this.longitude});
    FindBoundedMapPinCluster.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        count = json['count'];
        latitude = JsonConverters.toDouble(json['latitude']);
        longitude = JsonConverters.toDouble(json['longitude']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'count': count,
        'latitude': latitude,
        'longitude': longitude
    };

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

class Position implements IConvertible
{
    double? longitude;
    double? latitude;

    Position({this.longitude,this.latitude});
    Position.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        longitude = JsonConverters.toDouble(json['longitude']);
        latitude = JsonConverters.toDouble(json['latitude']);
        return this;
    }

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

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

class PlaceWithDisplayLocationDto implements IConvertible
{
    PlaceDto? place;
    Position? crowdedMapDisplayLocation;

    PlaceWithDisplayLocationDto({this.place,this.crowdedMapDisplayLocation});
    PlaceWithDisplayLocationDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'place': JsonConverters.toJson(place,'PlaceDto',context!),
        'crowdedMapDisplayLocation': JsonConverters.toJson(crowdedMapDisplayLocation,'Position',context!)
    };

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

class FindBoundedMapPlacesResponse implements IConvertible
{
    List<FindBoundedMapPinCluster>? clusters;
    List<PlaceWithDisplayLocationDto>? placesWithDisplayLocation;
    List<CategoryFacetTreeDto>? categoryFacetTrees;
    int? adMessageCount;
    int? adMessageSaveFoodAndMoneyCount;

    FindBoundedMapPlacesResponse({this.clusters,this.placesWithDisplayLocation,this.categoryFacetTrees,this.adMessageCount,this.adMessageSaveFoodAndMoneyCount});
    FindBoundedMapPlacesResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        clusters = JsonConverters.fromJson(json['clusters'],'List<FindBoundedMapPinCluster>',context!);
        placesWithDisplayLocation = JsonConverters.fromJson(json['placesWithDisplayLocation'],'List<PlaceWithDisplayLocationDto>',context!);
        categoryFacetTrees = JsonConverters.fromJson(json['categoryFacetTrees'],'List<CategoryFacetTreeDto>',context!);
        adMessageCount = json['adMessageCount'];
        adMessageSaveFoodAndMoneyCount = json['adMessageSaveFoodAndMoneyCount'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'clusters': JsonConverters.toJson(clusters,'List<FindBoundedMapPinCluster>',context!),
        'placesWithDisplayLocation': JsonConverters.toJson(placesWithDisplayLocation,'List<PlaceWithDisplayLocationDto>',context!),
        'categoryFacetTrees': JsonConverters.toJson(categoryFacetTrees,'List<CategoryFacetTreeDto>',context!),
        'adMessageCount': adMessageCount,
        'adMessageSaveFoodAndMoneyCount': adMessageSaveFoodAndMoneyCount
    };

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

class FindBoundedMapPlacesRequest implements IReturn<FindBoundedMapPlacesResponse>, IGet, IPost, ICacheable, IConvertible
{
    int? cacheVersion;
    QueryFilterDto? filter;
    MapBoundsDto? bounds;

    FindBoundedMapPlacesRequest({this.cacheVersion,this.filter,this.bounds});
    FindBoundedMapPlacesRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        cacheVersion = json['cacheVersion'];
        filter = JsonConverters.fromJson(json['filter'],'QueryFilterDto',context!);
        bounds = JsonConverters.fromJson(json['bounds'],'MapBoundsDto',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'cacheVersion': cacheVersion,
        'filter': JsonConverters.toJson(filter,'QueryFilterDto',context!),
        'bounds': JsonConverters.toJson(bounds,'MapBoundsDto',context!)
    };

    createResponse() => FindBoundedMapPlacesResponse();
    getResponseTypeName() => "FindBoundedMapPlacesResponse";
    getTypeName() => "FindBoundedMapPlacesRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'ConsumerApi', types: <String, TypeInfo> {
    'Parking': TypeInfo(TypeOf.Enum, enumValues:Parking.values),
    'PaymentOption': TypeInfo(TypeOf.Enum, enumValues:PaymentOption.values),
    'PriceMainDish': TypeInfo(TypeOf.Enum, enumValues:PriceMainDish.values),
    'DayOfWeek': TypeInfo(TypeOf.Enum, enumValues:DayOfWeek.values),
    'OpenAtTimeDto': TypeInfo(TypeOf.Class, create:() => OpenAtTimeDto()),
    'QueryFilterDto': TypeInfo(TypeOf.Class, create:() => QueryFilterDto()),
    'List<Parking>': TypeInfo(TypeOf.Class, create:() => <Parking>[]),
    'List<PaymentOption>': TypeInfo(TypeOf.Class, create:() => <PaymentOption>[]),
    'List<PriceMainDish>': TypeInfo(TypeOf.Class, create:() => <PriceMainDish>[]),
    'ICacheable': TypeInfo(TypeOf.Interface),
    'MapBoundsDto': TypeInfo(TypeOf.Class, create:() => MapBoundsDto()),
    'OpeningHour': TypeInfo(TypeOf.Class, create:() => OpeningHour()),
    'WeeklyOpeningHours': TypeInfo(TypeOf.Class, create:() => WeeklyOpeningHours()),
    'OpeningHours': TypeInfo(TypeOf.Class, create:() => OpeningHours()),
    'CategoryTreeDto': TypeInfo(TypeOf.Class, create:() => CategoryTreeDto()),
    'List<CategoryTreeDto>': TypeInfo(TypeOf.Class, create:() => <CategoryTreeDto>[]),
    'FeatureType': TypeInfo(TypeOf.Enum, enumValues:FeatureType.values),
    'IndividualFeatureDataDto': TypeInfo(TypeOf.Class, create:() => IndividualFeatureDataDto()),
    'BarSpecialityDto': TypeInfo(TypeOf.Class, create:() => BarSpecialityDto()),
    'BarTypeDto': TypeInfo(TypeOf.Class, create:() => BarTypeDto()),
    'BrandDto': TypeInfo(TypeOf.Class, create:() => BrandDto()),
    'PlaceCustomBrandDto': TypeInfo(TypeOf.Class, create:() => PlaceCustomBrandDto()),
    'PlaceSelectedBrandDto': TypeInfo(TypeOf.Class, create:() => PlaceSelectedBrandDto()),
    'CuisineDto': TypeInfo(TypeOf.Class, create:() => CuisineDto()),
    'MealTypeDto': TypeInfo(TypeOf.Class, create:() => MealTypeDto()),
    'ParkingDto': TypeInfo(TypeOf.Class, create:() => ParkingDto()),
    'PaymentOptionDto': TypeInfo(TypeOf.Class, create:() => PaymentOptionDto()),
    'EatingSuitabilityDto': TypeInfo(TypeOf.Class, create:() => EatingSuitabilityDto()),
    'TakeAwayDto': TypeInfo(TypeOf.Class, create:() => TakeAwayDto()),
    'WearPriceProfileDto': TypeInfo(TypeOf.Class, create:() => WearPriceProfileDto()),
    'MenuDto': TypeInfo(TypeOf.Class, create:() => MenuDto()),
    'ImageUrls': TypeInfo(TypeOf.Class, create:() => ImageUrls()),
    'PlaceType': TypeInfo(TypeOf.Enum, enumValues:PlaceType.values),
    'PriceMainDishDto': TypeInfo(TypeOf.Class, create:() => PriceMainDishDto()),
    'TimeZoneDto': TypeInfo(TypeOf.Class, create:() => TimeZoneDto()),
    'PlaceContact': TypeInfo(TypeOf.Class, create:() => PlaceContact()),
    'PlaceAddress': TypeInfo(TypeOf.Class, create:() => PlaceAddress()),
    'PlaceBasicDto': TypeInfo(TypeOf.Class, create:() => PlaceBasicDto()),
    'List<WearPriceProfileDto>': TypeInfo(TypeOf.Class, create:() => <WearPriceProfileDto>[]),
    'List<PlaceSelectedBrandDto>': TypeInfo(TypeOf.Class, create:() => <PlaceSelectedBrandDto>[]),
    'MallOtherServiceDto': TypeInfo(TypeOf.Class, create:() => MallOtherServiceDto()),
    'PlaceDto': TypeInfo(TypeOf.Class, create:() => PlaceDto()),
    'List<IndividualFeatureDataDto>': TypeInfo(TypeOf.Class, create:() => <IndividualFeatureDataDto>[]),
    'List<BarSpecialityDto>': TypeInfo(TypeOf.Class, create:() => <BarSpecialityDto>[]),
    'List<BarTypeDto>': TypeInfo(TypeOf.Class, create:() => <BarTypeDto>[]),
    'List<CuisineDto>': TypeInfo(TypeOf.Class, create:() => <CuisineDto>[]),
    'List<MealTypeDto>': TypeInfo(TypeOf.Class, create:() => <MealTypeDto>[]),
    'List<ParkingDto>': TypeInfo(TypeOf.Class, create:() => <ParkingDto>[]),
    'List<PaymentOptionDto>': TypeInfo(TypeOf.Class, create:() => <PaymentOptionDto>[]),
    'List<EatingSuitabilityDto>': TypeInfo(TypeOf.Class, create:() => <EatingSuitabilityDto>[]),
    'List<TakeAwayDto>': TypeInfo(TypeOf.Class, create:() => <TakeAwayDto>[]),
    'List<MenuDto>': TypeInfo(TypeOf.Class, create:() => <MenuDto>[]),
    'List<PlaceBasicDto>': TypeInfo(TypeOf.Class, create:() => <PlaceBasicDto>[]),
    'List<MallOtherServiceDto>': TypeInfo(TypeOf.Class, create:() => <MallOtherServiceDto>[]),
    'CategoryFacetTreeType': TypeInfo(TypeOf.Enum, enumValues:CategoryFacetTreeType.values),
    'CategoryFacetTreeDto': TypeInfo(TypeOf.Class, create:() => CategoryFacetTreeDto()),
    'List<FeatureType>': TypeInfo(TypeOf.Class, create:() => <FeatureType>[]),
    'List<CategoryFacetTreeDto>': TypeInfo(TypeOf.Class, create:() => <CategoryFacetTreeDto>[]),
    'FindBoundedMapPinCluster': TypeInfo(TypeOf.Class, create:() => FindBoundedMapPinCluster()),
    'Position': TypeInfo(TypeOf.Class, create:() => Position()),
    'PlaceWithDisplayLocationDto': TypeInfo(TypeOf.Class, create:() => PlaceWithDisplayLocationDto()),
    'FindBoundedMapPlacesResponse': TypeInfo(TypeOf.Class, create:() => FindBoundedMapPlacesResponse()),
    'List<FindBoundedMapPinCluster>': TypeInfo(TypeOf.Class, create:() => <FindBoundedMapPinCluster>[]),
    'List<PlaceWithDisplayLocationDto>': TypeInfo(TypeOf.Class, create:() => <PlaceWithDisplayLocationDto>[]),
    'FindBoundedMapPlacesRequest': TypeInfo(TypeOf.Class, create:() => FindBoundedMapPlacesRequest()),
});