ticketmaster-rs 0.0.9

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Event {
    pub name: Option<String>,

    #[serde(rename = "type")]
    pub event_type: String,

    pub id: String,

    pub test: bool,

    pub url: Option<String>,

    pub locale: String,

    pub images: Vec<Image>,

    pub sales: Option<Sales>,

    pub dates: Dates,

    #[serde(default)]
    pub classifications: Vec<Classification>,

    pub promoter: Option<Promoter>,

    #[serde(default)]
    pub promoters: Vec<Promoter>,

    #[serde(default)]
    pub price_ranges: Vec<PriceRange>,

    #[serde(default)]
    pub products: Vec<Product>,

    pub seatmap: Option<Seatmap>,

    pub accessibility: Option<Accessibility>,

    pub ticket_limit: Option<TicketLimit>,

    pub age_restrictions: Option<AgeRestrictions>,

    pub ticketing: Option<Ticketing>,

    #[serde(rename = "_links")]
    pub links: EventLinks,

    #[serde(rename = "_embedded")]
    #[serde(default)]
    pub embedded: EventEmbedded,

    pub info: Option<String>,

    pub please_note: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Accessibility {
    pub ticket_limit: Option<i64>,

    pub id: String,

    pub info: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgeRestrictions {
    pub legal_age_enforced: bool,

    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Classification {
    pub primary: bool,

    pub segment: Option<Genre>,

    pub genre: Option<Genre>,

    pub sub_genre: Option<Genre>,

    #[serde(rename = "type")]
    pub classification_type: Option<Genre>,

    pub sub_type: Option<Genre>,

    pub family: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Genre {
    pub id: String,

    pub name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Dates {
    pub start: Start,

    pub timezone: Option<String>,

    pub status: Status,

    pub span_multiple_days: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Start {
    pub local_date: Option<String>,

    pub local_time: Option<String>,

    pub date_time: Option<String>,

    #[serde(rename = "dateTBD")]
    pub date_tbd: bool,

    #[serde(rename = "dateTBA")]
    pub date_tba: bool,

    #[serde(rename = "timeTBA")]
    pub time_tba: bool,

    pub no_specific_time: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Status {
    pub code: String,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventEmbedded {
    #[serde(default)]
    pub venues: Vec<Venue>,

    #[serde(default)]
    pub attractions: Vec<Attraction>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Attraction {
    pub name: Option<String>,

    #[serde(rename = "type")]
    pub attraction_type: Option<String>,

    pub id: String,

    pub test: bool,

    pub url: Option<String>,

    pub locale: String,

    pub external_links: Option<ExternalLinks>,

    #[serde(default)]
    pub aliases: Vec<String>,

    #[serde(default)]
    pub images: Vec<Image>,

    #[serde(default)]
    pub classifications: Vec<Classification>,

    pub upcoming_events: AttractionUpcomingEvents,

    #[serde(rename = "_links")]
    pub links: AttractionLinks,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExternalLinks {
    #[serde(default)]
    pub twitter: Vec<SocialLink>,

    #[serde(default)]
    pub facebook: Vec<SocialLink>,

    #[serde(default)]
    pub wiki: Vec<SocialLink>,

    #[serde(default)]
    pub instagram: Vec<SocialLink>,

    #[serde(default)]
    pub homepage: Vec<SocialLink>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SocialLink {
    pub url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Image {
    pub ratio: Option<String>,

    pub url: Option<String>,

    pub width: i64,

    pub height: i64,

    pub fallback: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AttractionLinks {
    #[serde(rename = "self")]
    pub links_self: First,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct First {
    pub href: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AttractionUpcomingEvents {
    pub tmr: Option<i64>,

    pub ticketmaster: Option<i64>,

    #[serde(rename = "_total")]
    pub total: i64,

    #[serde(rename = "_filtered")]
    pub filtered: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Venue {
    pub name: Option<String>,

    #[serde(rename = "type")]
    pub venue_type: Option<String>,

    pub id: String,

    pub test: bool,

    pub url: Option<String>,

    pub locale: String,

    #[serde(default)]
    pub images: Vec<Image>,

    pub postal_code: Option<String>,

    pub timezone: Option<String>,

    pub city: City,

    pub state: Option<State>,

    pub country: Country,

    pub address: Option<Address>,

    pub location: Option<Location>,

    #[serde(default)]
    pub markets: Vec<Genre>,

    #[serde(default)]
    pub dmas: Vec<Dma>,

    pub upcoming_events: VenueUpcomingEvents,

    #[serde(rename = "_links")]
    pub links: AttractionLinks,

    pub box_office_info: Option<BoxOfficeInfo>,

    pub parking_detail: Option<String>,

    pub accessible_seating_detail: Option<String>,

    pub general_info: Option<GeneralInfo>,

    #[serde(default)]
    pub aliases: Vec<String>,

    pub social: Option<Social>,

    pub ada: Option<Ada>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Ada {
    pub ada_phones: Option<String>,

    pub ada_custom_copy: Option<String>,

    pub ada_hours: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Address {
    pub line1: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BoxOfficeInfo {
    pub phone_number_detail: Option<String>,

    pub open_hours_detail: Option<String>,

    pub accepted_payment_detail: Option<String>,

    pub will_call_detail: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct City {
    pub name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Country {
    pub name: Option<String>,

    pub country_code: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Dma {
    pub id: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GeneralInfo {
    pub general_rule: Option<String>,

    pub child_rule: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Location {
    pub longitude: String,

    pub latitude: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Social {
    pub twitter: Twitter,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Twitter {
    pub handle: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct State {
    pub name: Option<String>,

    pub state_code: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VenueUpcomingEvents {
    pub archtics: Option<i64>,

    pub ticketmaster: Option<i64>,

    #[serde(rename = "_total")]
    pub total: i64,

    #[serde(rename = "_filtered")]
    pub filtered: i64,

    pub tmr: Option<i64>,

    pub universe: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventLinks {
    #[serde(rename = "self")]
    pub links_self: First,

    #[serde(default)]
    pub attractions: Vec<First>,

    #[serde(default)]
    pub venues: Vec<First>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PriceRange {
    #[serde(rename = "type")]
    pub price_range_type: Option<String>,

    pub currency: String,

    pub min: Option<f64>,

    pub max: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Product {
    pub name: Option<String>,

    pub id: String,

    pub url: Option<String>,

    #[serde(rename = "type")]
    pub product_type: Option<String>,

    pub classifications: Vec<Classification>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Promoter {
    pub id: String,

    pub name: Option<String>,

    pub description: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Sales {
    pub public: Public,

    #[serde(default)]
    pub presales: Vec<Presale>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Presale {
    pub start_date_time: Option<String>,

    pub end_date_time: Option<String>,

    pub name: Option<String>,

    pub description: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Public {
    pub start_date_time: Option<String>,

    #[serde(rename = "startTBD")]
    pub start_tbd: bool,

    #[serde(rename = "startTBA")]
    pub start_tba: bool,

    pub end_date_time: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Seatmap {
    pub static_url: Option<String>,

    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TicketLimit {
    pub info: Option<String>,

    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Ticketing {
    pub safe_tix: SafeTix,

    #[serde(default)]
    pub all_inclusive_pricing: AllInclusivePricing,

    pub id: String,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AllInclusivePricing {
    pub enabled: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SafeTix {
    #[serde(default)]
    pub enabled: bool,

    #[serde(default)]
    pub in_app_only_enabled: bool,
}