/* Options:
Date: 2024-12-23 11:24:07
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: GetSavedSearchesRequest.*
//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;
}

class QueryLocationDto implements IConvertible
{
    double? longitude;
    double? latitude;
    double? searchRadiusInKm;

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

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

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

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

class CategoryDto implements IConvertible
{
    String? name;
    String? slug;
    String? absoluteSlug;
    String? imageUrl;
    String? allImageUrl;
    String? iconImageUrl;
    int? position;

    CategoryDto({this.name,this.slug,this.absoluteSlug,this.imageUrl,this.allImageUrl,this.iconImageUrl,this.position});
    CategoryDto.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'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'slug': slug,
        'absoluteSlug': absoluteSlug,
        'imageUrl': imageUrl,
        'allImageUrl': allImageUrl,
        'iconImageUrl': iconImageUrl,
        'position': position
    };

    getTypeName() => "CategoryDto";
    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 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 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 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 FilterDetails implements IConvertible
{
    List<CategoryDto>? categories;
    List<BarSpecialityDto>? barSpecialities;
    List<BarTypeDto>? barTypes;
    List<BrandDto>? brands;
    List<CuisineDto>? cuisines;
    List<MealTypeDto>? mealTypes;
    List<ParkingDto>? parking;
    List<PaymentOptionDto>? paymentOptions;
    List<PriceMainDishDto>? priceMainDishes;
    List<EatingSuitabilityDto>? eatingSuitability;
    List<TakeAwayDto>? takeAways;
    List<WearPriceProfileDto>? wearPriceProfiles;
    List<CategoryDto>? rootCategories;

    FilterDetails({this.categories,this.barSpecialities,this.barTypes,this.brands,this.cuisines,this.mealTypes,this.parking,this.paymentOptions,this.priceMainDishes,this.eatingSuitability,this.takeAways,this.wearPriceProfiles,this.rootCategories});
    FilterDetails.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        categories = JsonConverters.fromJson(json['categories'],'List<CategoryDto>',context!);
        barSpecialities = JsonConverters.fromJson(json['barSpecialities'],'List<BarSpecialityDto>',context!);
        barTypes = JsonConverters.fromJson(json['barTypes'],'List<BarTypeDto>',context!);
        brands = JsonConverters.fromJson(json['brands'],'List<BrandDto>',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!);
        priceMainDishes = JsonConverters.fromJson(json['priceMainDishes'],'List<PriceMainDishDto>',context!);
        eatingSuitability = JsonConverters.fromJson(json['eatingSuitability'],'List<EatingSuitabilityDto>',context!);
        takeAways = JsonConverters.fromJson(json['takeAways'],'List<TakeAwayDto>',context!);
        wearPriceProfiles = JsonConverters.fromJson(json['wearPriceProfiles'],'List<WearPriceProfileDto>',context!);
        rootCategories = JsonConverters.fromJson(json['rootCategories'],'List<CategoryDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'categories': JsonConverters.toJson(categories,'List<CategoryDto>',context!),
        'barSpecialities': JsonConverters.toJson(barSpecialities,'List<BarSpecialityDto>',context!),
        'barTypes': JsonConverters.toJson(barTypes,'List<BarTypeDto>',context!),
        'brands': JsonConverters.toJson(brands,'List<BrandDto>',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!),
        'priceMainDishes': JsonConverters.toJson(priceMainDishes,'List<PriceMainDishDto>',context!),
        'eatingSuitability': JsonConverters.toJson(eatingSuitability,'List<EatingSuitabilityDto>',context!),
        'takeAways': JsonConverters.toJson(takeAways,'List<TakeAwayDto>',context!),
        'wearPriceProfiles': JsonConverters.toJson(wearPriceProfiles,'List<WearPriceProfileDto>',context!),
        'rootCategories': JsonConverters.toJson(rootCategories,'List<CategoryDto>',context!)
    };

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

class SavedSearchDto implements IConvertible
{
    int? id;
    String? name;
    QueryFilterDto? filter;
    QueryLocationDto? location;
    FilterDetails? filterDetails;
    DateTime? createdAt;
    DateTime? updatedAt;

    SavedSearchDto({this.id,this.name,this.filter,this.location,this.filterDetails,this.createdAt,this.updatedAt});
    SavedSearchDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        filter = JsonConverters.fromJson(json['filter'],'QueryFilterDto',context!);
        location = JsonConverters.fromJson(json['location'],'QueryLocationDto',context!);
        filterDetails = JsonConverters.fromJson(json['filterDetails'],'FilterDetails',context!);
        createdAt = JsonConverters.fromJson(json['createdAt'],'DateTime',context!);
        updatedAt = JsonConverters.fromJson(json['updatedAt'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'filter': JsonConverters.toJson(filter,'QueryFilterDto',context!),
        'location': JsonConverters.toJson(location,'QueryLocationDto',context!),
        'filterDetails': JsonConverters.toJson(filterDetails,'FilterDetails',context!),
        'createdAt': JsonConverters.toJson(createdAt,'DateTime',context!),
        'updatedAt': JsonConverters.toJson(updatedAt,'DateTime',context!)
    };

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

class GetSavedSearchesResponse implements IConvertible
{
    List<SavedSearchDto>? searches;

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

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

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

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

// @Route("/searches/GetSavedSearches", "GET")
class GetSavedSearchesRequest implements IReturn<GetSavedSearchesResponse>, IGet, IConvertible
{
    GetSavedSearchesRequest();
    GetSavedSearchesRequest.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    createResponse() => GetSavedSearchesResponse();
    getResponseTypeName() => "GetSavedSearchesResponse";
    getTypeName() => "GetSavedSearchesRequest";
    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>[]),
    'QueryLocationDto': TypeInfo(TypeOf.Class, create:() => QueryLocationDto()),
    'CategoryDto': TypeInfo(TypeOf.Class, create:() => CategoryDto()),
    'BarSpecialityDto': TypeInfo(TypeOf.Class, create:() => BarSpecialityDto()),
    'BarTypeDto': TypeInfo(TypeOf.Class, create:() => BarTypeDto()),
    'BrandDto': TypeInfo(TypeOf.Class, create:() => BrandDto()),
    'CuisineDto': TypeInfo(TypeOf.Class, create:() => CuisineDto()),
    'MealTypeDto': TypeInfo(TypeOf.Class, create:() => MealTypeDto()),
    'ParkingDto': TypeInfo(TypeOf.Class, create:() => ParkingDto()),
    'PaymentOptionDto': TypeInfo(TypeOf.Class, create:() => PaymentOptionDto()),
    'PriceMainDishDto': TypeInfo(TypeOf.Class, create:() => PriceMainDishDto()),
    'EatingSuitabilityDto': TypeInfo(TypeOf.Class, create:() => EatingSuitabilityDto()),
    'TakeAwayDto': TypeInfo(TypeOf.Class, create:() => TakeAwayDto()),
    'WearPriceProfileDto': TypeInfo(TypeOf.Class, create:() => WearPriceProfileDto()),
    'FilterDetails': TypeInfo(TypeOf.Class, create:() => FilterDetails()),
    'List<CategoryDto>': TypeInfo(TypeOf.Class, create:() => <CategoryDto>[]),
    'List<BarSpecialityDto>': TypeInfo(TypeOf.Class, create:() => <BarSpecialityDto>[]),
    'List<BarTypeDto>': TypeInfo(TypeOf.Class, create:() => <BarTypeDto>[]),
    'List<BrandDto>': TypeInfo(TypeOf.Class, create:() => <BrandDto>[]),
    '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<PriceMainDishDto>': TypeInfo(TypeOf.Class, create:() => <PriceMainDishDto>[]),
    'List<EatingSuitabilityDto>': TypeInfo(TypeOf.Class, create:() => <EatingSuitabilityDto>[]),
    'List<TakeAwayDto>': TypeInfo(TypeOf.Class, create:() => <TakeAwayDto>[]),
    'List<WearPriceProfileDto>': TypeInfo(TypeOf.Class, create:() => <WearPriceProfileDto>[]),
    'SavedSearchDto': TypeInfo(TypeOf.Class, create:() => SavedSearchDto()),
    'GetSavedSearchesResponse': TypeInfo(TypeOf.Class, create:() => GetSavedSearchesResponse()),
    'List<SavedSearchDto>': TypeInfo(TypeOf.Class, create:() => <SavedSearchDto>[]),
    'GetSavedSearchesRequest': TypeInfo(TypeOf.Class, create:() => GetSavedSearchesRequest()),
});