// vim:set sw=2 ts=2 sts et:
//
// Copyright 2024 Rutger Broekhoff. Licensed under the EUPL.

#ifndef OEUF_LIBTMI8_KV1_TYPES_HPP
#define OEUF_LIBTMI8_KV1_TYPES_HPP

#include <chrono>
#include <cstdint>
#include <optional>
#include <string>
#include <variant>

struct Kv1OrganizationalUnit;
struct Kv1HigherOrganizationalUnit;
struct Kv1UserStopPoint;
struct Kv1UserStopArea;
struct Kv1TimingLink;
struct Kv1Link;
struct Kv1Line;
struct Kv1Destination;
struct Kv1JourneyPattern;
struct Kv1ConcessionFinancerRelation;
struct Kv1ConcessionArea;
struct Kv1Financer;
struct Kv1JourneyPatternTimingLink;
struct Kv1Point;
struct Kv1PointOnLink;
struct Kv1Icon;
struct Kv1Notice;
struct Kv1NoticeAssignment;
struct Kv1TimeDemandGroup;
struct Kv1TimeDemandGroupRunTime;
struct Kv1PeriodGroup;
struct Kv1SpecificDay;
struct Kv1TimetableVersion;
struct Kv1PublicJourney;
struct Kv1PeriodGroupValidity;
struct Kv1ExceptionalOperatingDay;
struct Kv1ScheduleVersion;
struct Kv1PublicJourneyPassingTimes;
struct Kv1OperatingDay;

struct Kv1Records {
  std::vector<Kv1OrganizationalUnit>         organizational_units;
  std::vector<Kv1HigherOrganizationalUnit>   higher_organizational_units;
  std::vector<Kv1UserStopPoint>              user_stop_points;
  std::vector<Kv1UserStopArea>               user_stop_areas;
  std::vector<Kv1TimingLink>                 timing_links;
  std::vector<Kv1Link>                       links;
  std::vector<Kv1Line>                       lines;
  std::vector<Kv1Destination>                destinations;
  std::vector<Kv1JourneyPattern>             journey_patterns;
  std::vector<Kv1ConcessionFinancerRelation> concession_financer_relations;
  std::vector<Kv1ConcessionArea>             concession_areas;
  std::vector<Kv1Financer>                   financers;
  std::vector<Kv1JourneyPatternTimingLink>   journey_pattern_timing_links;
  std::vector<Kv1Point>                      points;
  std::vector<Kv1PointOnLink>                point_on_links;
  std::vector<Kv1Icon>                       icons;
  std::vector<Kv1Notice>                     notices;
  std::vector<Kv1NoticeAssignment>           notice_assignments;
  std::vector<Kv1TimeDemandGroup>            time_demand_groups;
  std::vector<Kv1TimeDemandGroupRunTime>     time_demand_group_run_times;
  std::vector<Kv1PeriodGroup>                period_groups;
  std::vector<Kv1SpecificDay>                specific_days;
  std::vector<Kv1TimetableVersion>           timetable_versions;
  std::vector<Kv1PublicJourney>              public_journeys;
  std::vector<Kv1PeriodGroupValidity>        period_group_validities;
  std::vector<Kv1ExceptionalOperatingDay>    exceptional_operating_days;
  std::vector<Kv1ScheduleVersion>            schedule_versions;
  std::vector<Kv1PublicJourneyPassingTimes>  public_journey_passing_times;
  std::vector<Kv1OperatingDay>               operating_days;

  size_t size() const;
};

// These definitions implement TMI8, KV1 Dienstregeling (Timetable) version
// 8.3.0.2 (release), published by BISON on January 8, 2020.
// (Filename: tmi8 dienstregeling (kv 1) v8.3.0.2, release.docx)
//
// This specification and other BISON specifications, as well as other
// supplementary information, can be found on BISON's website:
//   https://bison.dova.nu/ 
//
// The specification that was used to create these definitions was downloaded
// from the following address:
//   https://bison.dova.nu/sites/default/files/bestanden/tmi8_dienstregeling_kv_1_v8.3.0.2_release.pdf
//
// The KV1 table structure and the corresponding documentation describing the
// relevant tables and fields, as presented here, is derived from the original
// specification. Most documentation is a manually translated version of the
// documentation as present in the specification. The specification is licensed
// under CC BY-ND 3.0. The exact text of this license can be found on
// https://creativecommons.org/licenses/by-nd/3.0/nl/.

// KV1 Table 1: Organizational Unit [ORUN] (MANDATORY)
// 
// A collection of trips with the same validity features. An organizational
// unit can be part of a 'higher' unit.
//
// An organizational unit is defined as a unity vor which the planning of trips
// is compiled. When defining the organizational units, it is important that
// all trips within the package have a homogeneous validity (school holidays,
// shopping Sundays, foreign bank holidays).
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1OrganizationalUnit {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string organizational_unit_code;

    explicit Key(std::string data_owner_code,
                 std::string organizational_unit_code);
  };
  
  Key key;
  // Mandatory, at most 50 characters.
  std::string name;
  // Mandatory, at most 10 characters.
  std::string organizational_unit_type;
  // Optional, at most 255 characters.
  std::string description;
};

// KV1 Table 2: Higher Organizational Unit [ORUNORUN] (OPTIONAL)
// 
// An in the hierarchy higher-ordered organizational unit for the purpose of
// (among others) recording of (deviating) validities on the high level.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1HigherOrganizationalUnit {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Parent, higher organizational unit
    // that is referred to.
    std::string organizational_unit_code_parent;
    // Mandatory (key), at most 10 characters. Child, lower organizational unit.
    std::string organizational_unit_code_child;
    // Mandatory (key), at most 10 characters. [YYYY-MM-DD] Starting date of the
    // hierarchical relation (can be a fixed value, e.g. 2006-12-31).
    std::chrono::year_month_day valid_from;

    explicit Key(std::string data_owner_code,
                 std::string organizational_unit_code_parent,
                 std::string organizational_unit_code_child,
                 std::chrono::year_month_day valid_from);
  };
 
  Key key;

  Kv1OrganizationalUnit *p_organizational_unit_parent = nullptr;
  Kv1OrganizationalUnit *p_organizational_unit_child  = nullptr;
};

// KV1 Table 3: User Stop Point [USRSTOP]
// 
// Stop or other point (e.g. Bridge, functioning as info for the bridge keeper)
// for which times are recorded in the planning system of the transit operator.
// 
// Coordinates of a UserStopPoint are recorded as Point. When defining
// UserStopPoints, it is important that the coordinates can be unambiguously
// and verifiably recorded. For a stop, the coordinates of the stop sign are
// recorded. If there is no stop sign, the end of the bus stop (where the bus
// normally halts) is recorded as the coordinate of the stop.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1UserStopPoint {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Stop number in domain of operator.
    std::string user_stop_code;

    explicit Key(std::string data_owner_code,
                 std::string user_stop_code);
  };

  Key key;
  // Optional, at most 10 characters. Stop number in domain of integrator,
  // (initially) equal to UserStopCode.
  std::string timing_point_code;
  // Mandatory, at most 5 characters. Boolean indicator whether USRSTOP is used
  // as boarding stop, true by default. False for e.g. dummy stop for bridge
  // keeper.
  bool get_in = true;
  // Mandatory, at most 5 characters. Boolean indicator whether USRSTOP is used
  // as alighting stop.
  bool get_out = false;
  // Mandatory, at most 50 characters. Stop name.
  std::string name;
  // Mandatory, at most 50 characters. Town name.
  std::string town;
  // Optional, at most 10 characters. Reference to StopArea of which the
  // UserStop is part.
  std::string user_stop_area_code;
  // Mandatory, at most 10 characters. Platform indication/letter. The '-'
  // value is used to indication that this is not applicable.
  std::string stop_side_code;
  // Mandatory, at most 5 digits. Minimal stop duration for boarding and
  // alighting, zero by default. In seconds.
  double minimal_stop_time_s = 0;
  // Optional, at most 3 digits. Length of stop platform.
  std::optional<double> stop_side_length;
  // Optional, at most 255 characters.
  std::string description;
  // Mandatory, at most 10 characters. USRSTOPTYPE. Indicates the stop kind.
  std::string user_stop_type;
  // Optional, at most 30 characters. Nationally unique stop number.
  std::string quay_code;

  Kv1UserStopArea *p_user_stop_area = nullptr;
  Kv1Point        *p_point          = nullptr;
};

// KV1 Table 4: User Stop Area [USRSTAR]
//
// A StopArea is a collection of stops, which have the same name for passengers
// and logically belong together. (E.g. a bus station of transfer point.) Stops
// lying opposite each other can also form a StopArea.
//
// Used for display of all stops in a stop area on an overview display and for
// announcement of stop names (stops on both sides of the street share the same
// name).
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1UserStopArea {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Code of StopArea following coding
    // of operator, e.g. PlaceCode.
    std::string user_stop_area_code;

    explicit Key(std::string data_owner_code,
                 std::string user_stop_area_code);
  };

  Key key;
  // Mandatory, at most 50 characters.
  std::string name;
  // Mandatory, at most 50 characters.
  std::string town;
  // Mandatory, at most 255 characters.
  std::string description;
};

// KV1 Table 5: Timing Link [TILI]
// 
// Link between two points which have the feature 'stop' or 'timing point'. A
// Timing Link is set between all stops and other timing points (e.g. for the
// bridge) which make part of a journey pattern.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1TimingLink {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Stop number in the domain of
    // DataOwner (here: the operator).
    std::string user_stop_code_begin;
    // Mandatory (key), at most 10 characters. Stop number in the domain of
    // DataOwner (here: the operator).
    std::string user_stop_code_end;

    explicit Key(std::string data_owner_code,
                 std::string user_stop_code_begin,
                 std::string user_stop_code_end);
  };

  Key key;
  // Optional, at most 5 digits. Minimal trip time (in seconds).
  std::optional<double> minimal_drive_time_s;
  // Optional, at most 255 characters.
  std::string description;

  Kv1UserStopPoint *p_user_stop_begin = nullptr;
  Kv1UserStopPoint *p_user_stop_end   = nullptr;
};

// KV1 Table 6: Link [LINK]
//
// A route link describes the connection between to points on the physical path
// of a route.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1Link {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Stop code in the domain of
    // DataOwner (here: the operator).
    std::string user_stop_code_begin;
    // Mandatory (key), at most 10 characters. Stop code in the domain of
    // DataOwner (here: the operator).
    std::string user_stop_code_end;
    // Mandatory (key), at most 5 characters. Modality for which the distance
    // applies, see BISON enumeration E9.
    // TODO: Check if BISON enumeration E9 can be put into an enum.
    std::string transport_type;

    explicit Key(std::string data_owner_code,
                 std::string user_stop_code_begin,
                 std::string user_stop_code_end,
                 std::string transport_type);
  };

  Key key;
  // Mandatory, at most 6 digits. Length of the link (in meters).
  double distance = 0;
  // Optional, at most 255 characters.
  std::string description;

  Kv1UserStopPoint *p_user_stop_begin = nullptr;
  Kv1UserStopPoint *p_user_stop_end   = nullptr;
};

struct RgbColor {
  uint8_t r, g, b = 0;
};

// KV1 Table 7: Line [LINE]
//
// A line is a collection of routes/journey patterns which is publically known
// under a shared number.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1Line {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Unique system line number in the
    // domain of DataOwner.
    std::string line_planning_number;

    explicit Key(std::string data_owner_code,
                 std::string line_planning_number);
  };

  Key key;
  // Mandatory, at most 4 characters. Line number for the public, incl. S/N
  // indications.
  std::string line_public_number;
  // Mandatory, at most 50 characters.
  std::string line_name;
  // Mandatory, at most three digits. Should be in the range [0, 400).
  // Only processing Connexxion's KV1 export, however, shows us that this range
  // constrained is not honored in practice. That is why we also don't care.
  short line_ve_tag_number = 0;
  // Optional, at most 255 characters.
  std::string description;
  // Mandatory, at most 5 characters. Modality, see BISON enumeration E9.
  // TODO: Check if BISON enumeration E9 can be put into an enum.
  std::string transport_type;
  // Optional, at most 4 digits. Symbol / image for the line. Reference to ICON
  // table.
  std::optional<short> line_icon;
  // Optional, at most four characters. Background color for the line.
  // Hexadecimal representation following RGB coding. Always six characters
  // (RRGGBB), only numbers and/or capital letters.
  std::optional<RgbColor> line_color;
  // Optional, at most four characters. Foreground color for the line.
  // Hexadecimal representation following RGB coding. Always six characters
  // (RRGGBB), only numbers and/or capital letters.
  std::optional<RgbColor> line_text_color;

  Kv1Icon *p_line_icon = nullptr;
};

// KV1 Table 8: Destination [DEST]
//
// A destination shows the place/district/description of the route for the
// passenger. Intermediate and detail destinations of a journey pattern are
// shown under a single desination code, together with the primary destination.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1Destination {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string dest_code;

    explicit Key(std::string data_owner_code,
                 std::string dest_code);
  };

  Key key;
  // Mandatory, at most 50 characters. Full destination (e.g. compiled from
  // primary, detail or intermediate destination).
  std::string dest_name_full;
  // Mandatory, at most 24 characters. Primary / intermediate destination in
  // enumeration / final destination if 1 line is used.
  std::string dest_name_main;
  // Optional, at most 24 characters. Detail/secondary or intermediate
  // destination for primary desination, final destination (for intermediate
  // destination on line 1).
  std::string dest_name_detail;
  // Mandatory, at most 5 characters. Boolean which indcates whether
  // DestNameDetail must always be shown (e.g. because this contains an
  // important intermediate destination.)
  bool relevant_dest_name_detail = false;
  // Mandatory, at most 21 characters. Primary destination in 21 characters.
  std::string dest_name_main_21;
  // Optional, at most 21 characters. Detail/secondary/intermediate destination
  // in 21 characters.
  std::string dest_name_detail_21;
  // Mandatory, at most 19 characters. Primary destination in 19 characters.
  std::string dest_name_main_19;
  // Optional, at most 19 characters. Detail/secondary/intermediate destination
  // in 19 characters.
  std::string dest_name_detail_19;
  // Mandatory, at most 16 characters. Primary destination in 16 characters.
  std::string dest_name_main_16;
  // Optional, at most 16 characters. Detail/secondary/intermediate destination
  // in 16 characters.
  std::string dest_name_detail_16;
  // Optional, at most 4 digits. Symbol/image for the destination. Reference to
  // the ICON table.
  std::optional<short> dest_icon;
  // Optional, at most 6 characters. Background color for the destination.
  // Hexadecimal representation following RGB coding. Always six characters
  // (RRGGBB), only six digits and/or capital letters.
  std::optional<RgbColor> dest_color;
  // Optional, at most 30 characters (WTF?). Foreground color for the
  // destination. Hexadecimal representation following RGB coding. Always six
  // characters (RRGGBB), only six digits and/or capital letters.
  std::optional<RgbColor> dest_text_color;
};

// KV1 Table 9: Journey Pattern [JOPA]
//
// The journey pattern describes the route from start to end point as a ordered
// list of stops and links between stops/timing points.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1JourneyPattern {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string line_planning_number;
    // Mandatory (key), at most 10 characters.
    std::string journey_pattern_code;

    explicit Key(std::string data_owner_code,
                 std::string line_planning_number,
                 std::string journey_pattern_code);
  };

  Key key;
  // Mandatory, at most 10 characters. Refers to a journey pattern type
  // (JOPATYPE).
  std::string journey_pattern_type;
  // Mandatory, at most 1 character. One of [1, 2, A, B].
  char direction = 0;
  // Optional, at most 255 characters.
  std::string description;

  Kv1Line *p_line = nullptr;
};

// KV1 Table 10: Concession Financer Relation [CONFINREL]
//
// Concession financer relation (mainly parcel). Smallest unit for which data
// about a concession can be captured in relation to a financer and/or
// concession.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1ConcessionFinancerRelation {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Parcel code.
    std::string con_fin_rel_code;

    explicit Key(std::string data_owner_code,
                 std::string con_fin_rel_code);
  };

  Key key;
  // Mandatory, at most 10 characters. Concession code.
  std::string concession_area_code;
  // Optional, at most 10 characters. Code of financer/client of the parcel.
  std::string financer_code;

  Kv1ConcessionArea *p_concession_area = nullptr;
  Kv1Financer       *p_financer        = nullptr;
};

// KV1 Table 11: Concession Area [CONAREA]
//
// Concession (area).
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1ConcessionArea {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Code of the concession.
    std::string concession_area_code;

    explicit Key(std::string data_owner_code,
                 std::string concession_area_code);
  };

  Key key;
  // Mandatory, at most 255 characters.
  std::string description;
};

// KV1 Table 12: Financer [FINANCER] (OPTIONAL)
//
// Financer of a parcel.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1Financer {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string financer_code;

    explicit Key(std::string data_owner_code,
                 std::string financer_code);
  };

  Key key;
  // Mandatory, at most 255 characters.
  std::string description;
};

// KV1 Table 13: Journey Pattern Timing Link [JOPATILI]
//
// Compilation of journey pattern from logical links (between pairs of
// stops/timing points). Features such as the destination code, the public line
// number, the concession financer relation (parcel) and product formula are
// set per connection. Moreover, a color and/or image linked to the line
// destination and the use of the (first) stop as boarding/alighting stop can
// be set per link.
//
// Timing Link: A timing link is a stop, set by the transit operator, where a
// bus / public transit vehicle may never depart earlier than set in the
// timetable.
//
// A logical link may never occur more than once in a journey pattern.
// Therefore, the combination of LinePlanningNumber, JourneyPatternCode,
// UserStopCodeBegin and UserStopCodeEnd must be unique in JOPATILI.
//
// The value of GetIn and GetOut are normally copied from the corresponding
// stop in the USRSTOP table, but can be overruled per journey pattern if so
// desired.
//
// A Icon or (Text)Color set here overrules the general value of the
// corresponding line (Line) or destination (Destination).
//
// A value of ShowFlexibleTrip or ProductFormulaType in PUJO or PUJOPASS
// overrules the value in JOPATILI.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1JourneyPatternTimingLink {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string line_planning_number;
    // Mandatory (key), at most 10 characters.
    std::string journey_pattern_code;
    // Mandatory (key), at most 3 digits.
    short timing_link_order = 0;

    explicit Key(std::string data_owner_code,
                 std::string line_planning_number,
                 std::string journey_pattern_code,
                 short timing_link_order);
  };

  Key key;
  // Mandatory, at most 10 characters. Stop number in the domain of the
  // DataOwner (here: the transit operator).
  std::string user_stop_code_begin;
  // Mandatory, at most 10 characters. Stop number in the domain of the
  // DataOwner (here: the transit operator).
  std::string user_stop_code_end;
  // Mandatory, at most 10 characters. Concession financer relation / parcel
  // (smallest unit).
  std::string con_fin_rel_code;
  // Mandatory, at most 10 characters. The destination (incl. intermediat
  // destinations) as these are shown at the first stop of the journey pattern
  // link.
  std::string dest_code;
  // Mandatory, at most 5 characters. Boolean which indicates whether the first
  // stop of the connection is a timing stop. Indicator is at least "true" at
  // first stop of a line and at waiting stops.
  bool is_timing_stop = false;
  // Optional, at most 4 characters. Public line number which must be shown on
  // displays from the first stop of the journey pattern link (e.g. Line number
  // + S). This is important when a deviating public line number applies from a
  // certain point on forward. Normally, the public line number of the
  // corresponding line is shown.
  std::string display_public_line;
  // Optional, at most 4 digits. Enumeration E10 (see section 2.5). A public
  // transit service which distinguishes itself by a set of unique features,
  // that is offered to the passenger as distinct (a marketing aspect).
  // TODO: Check if we can turn BISON enumeration E10 into an enum
  std::optional<short> product_formula_type;
  // Mandatory, at most 5 characters. Boolean indicator whether UserStopBegin
  // is used as a boarding stop in this journey pattern. Usually equal to the
  // value of the corresponding USRSTOP.
  bool get_in = false;
  // Mandatory, at most 5 characters. Boolean indicator whether UserStopBegin
  // is used as an alighting stop in this journey pattern. Usually equal to the
  // value of the corresponding USRSTOP.
  bool get_out = false;
  // Optional, at most 8 characters. Indicates whether the transit operator
  // wants a not explicitly planned trip (i.e. a trip that only operates after
  // reservation such as a 'call bus' (belbus), 'line taxi' (lijntaxi) etc.) to
  // be shown on displays. Values according enumeration E21: TRUE (always),
  // FALSE (never), REALTIME (only when tracking trip).
  // TODO: Check if we can turn BISON enumeration E21 into an enum
  std::string show_flexible_trip;
  // Optional, at most 4 digits. Symbol / image for display of the line
  // destination at the journey stop passing. Reference to the ICON table.
  std::optional<short> line_dest_icon;
  // Optional, at most 6 characters. Background color for display of the line
  // destination at a journey stop passing. Hexadecimal representation
  // following RGB coding. Always six characters (RRGGBB), only numbers and/or
  // capital letters.
  std::optional<RgbColor> line_dest_color;
  // Optional, at most 6 characters. Foreground color for display of the line
  // destination at a journey stop passing. Hexadecimal representation
  // following RGB coding. Always six characters (RRGGBB), only numbers and/or
  // capital letters.
  std::optional<RgbColor> line_dest_text_color;

  Kv1Line                       *p_line            = nullptr;
  Kv1JourneyPattern             *p_journey_pattern = nullptr;
  Kv1UserStopPoint              *p_user_stop_begin = nullptr;
  Kv1UserStopPoint              *p_user_stop_end   = nullptr;
  Kv1ConcessionFinancerRelation *p_con_fin_rel     = nullptr;
  Kv1Destination                *p_dest            = nullptr;
  Kv1Icon                       *p_line_dest_icon  = nullptr;
};

// KV1 Table 14: Point [POINT]
//
// A point is the smallest location which can be reffered to within the public
// transit network. Every stop (USRSTOP) is a point.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1Point {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string point_code;

    explicit Key(std::string data_owner_code,
                 std::string point_code);
  };

  Key key;
  // Mandatory, at most 10 characters. Refers to the POINTTYPE table.
  std::string point_type;
  // Mandatory, at most 10 characters. Refers to the GEOSYSTYPE table. Only
  // allowed to have the value "RD" (rijkdsdriehoekstelsel; the national Dutch
  // coordinate system).
  std::string coordinate_system_type;
  // Mandatory, at most 15 characters. X position in the RD coordinate system,
  // in meters (at least 6 digits).
  double location_x_ew = 0;
  // Mandatory, at most 15 characters. Y position in the RD coordinate system,
  // in meters (at least 6 digits).
  double location_y_ns = 0;
  // Optional, at most 15 characters.
  // NOTE: the standart (presumeably wrongly) indicates this field as having
  // alphanumeric contents.
  std::optional<double> location_z;
  // Optional, at most 255 characters.
  std::string description;
};

// KV1 Table 15: Point on Link [POOL]
//
// A point that is used to geographically describe the trajectory between two
// stops.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1PointOnLink {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Stop number in the domain of the
    // DataOwner (here: transit operator).
    std::string user_stop_code_begin;
    // Mandatory (key), at most 10 characters. Stop number in the domain of the
    // DataOwner (here: transit operator).
    std::string user_stop_code_end;
    // Mandatory (key), at most 10 characters. Code from the road manager for KAR
    // points. For curve points of the DataOwner (often the transit operator).
    std::string point_data_owner_code;
    // Mandatory (key), at most 10 charcters.
    std::string point_code;
    // Mandatory (key), at most 5 characters. Modality for which the distance
    // applies, see BISON enumeration E9.
    std::string transport_type;

    explicit Key(std::string data_owner_code,
                 std::string user_stop_code_begin,
                 std::string user_stop_code_end,
                 std::string point_data_owner_code,
                 std::string point_code,
                 std::string transport_type);
  };

  Key key;
  // Mandatory, at most 5 digits. Distance in meters relative to the start of
  // the link.
  double distance_since_start_of_link = 0;
  // Optional, at most 4 digits. Crossing speed for a public transit vehicle
  // from the previous point (on a link) in m/s.
  std::optional<double> segment_speed_mps = 0;
  // Optional, at most 4 digits. Comfort speed for a public transit vehicle on
  // the curve point.
  std::optional<double> local_point_speed_mps = 0;
  // Optional, at most 255 characters.
  std::string description;

  Kv1UserStopPoint *p_user_stop_begin = nullptr;
  Kv1UserStopPoint *p_user_stop_end   = nullptr;
  Kv1Point         *p_point           = nullptr;
};

// KV1 Table 16: Icon [ICON]
//
// Table with images which can be referred to from DEST.DestIcon, LINE.LineIcon
// and JOPATILI.LineDestIcon to load the correct image.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1Icon {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 4 digits. Reference from other tables for the
    // requested image.
    short icon_number = 0;

    explicit Key(std::string data_owner_code,
                 short icon_number);
  };

  Key key;
  // Mandatory, at most 1024 characters. Absolute URI to a publically available
  // location from which the image can be loaded. The extension of the file
  // indicates the image type.
  // Supported file types are: GIF (.gif), JPEG (.jpg, .jpeg),
  //                           PNG (.png), SVG (.svg)
  // Supported protocols are: HTTP, HTTPS, FTP
  // Prefer to not use any capital letters. Examples:
  //   - http://bison.dova.nu/images/logo.png
  //   - https://bison.dova.nu/images/logo.png
  //   - ftp://ftp.dova.nu/images/logo.png
  std::string icon_uri;
};

// KV1 Table 17: Notice [NOTICE] (OPTIONAL)
//
// A (reusable) text with supplementary information about exceptions /
// clarifications for a line, journey pattern etc.
// 
// Usage is optional; when there are no clarifying texts, the NOTICE table does
// not need to be provided in a KV1 set.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1Notice {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 20 characters. Identification of Notice (remark,
    // clarifying text).
    std::string notice_code;

    explicit Key(std::string data_owner_code,
                 std::string notice_code);
  };

  Key key;
  // Mandatory, at most 1024 characters. Content, text. Contains contact
  // information such as telephone number, web address and reservation time for
  // 'call buses' (belbussen) and other demand-based transit.
  std::string notice_content;
};

// KV1 Table 18: Notice Assignment [NTCASSGNM] (OPTIONAL)
//
// Linking table in which Notice (remark, clarfiying text) is assigned to a
// line, journey pattern, stops within a journey pattern, journey etc. Notice
// Assignment contains all logical key elements of the corresponding objects to
// which a Notice can be assigned.
//
// Different attributes are required for the Notice Assignment, depending on
// the type object to which the Notice is assigned. In the following table
// structure, this is indicated as 'Only relevant for ...'. This means that
// fields for other object types in the Notice Assignment can be ignored.
//
// Moreover, it can also occur that not all key fields of the linked table are
// of interest (content-wise) for recording the Notice.
//
// Both matters are summarised in this overview:
//
//   --------------------------------------------------------
//   AssignedObject          PUJO   PUJOPASS   LINE  JOPATILI
//   --------------------------------------------------------
//   DataOwnerCode........... x ...... x ...... x ..... x ...
//   TimetableVersionCode ... o .............................
//   OrganizationalUnitCode . o ...... o ....................
//   ScheduleCode .................... o ....................
//   ScheduleTypeCode ................ o ....................
//   PeriodGroupCode ........ o .............................
//   SpecificDayCode ........ o .............................
//   DayType ................ o .............................
//   LinePlanningNumber ..... x ...... x ...... x ..... x ...
//   JourneyNumber .......... x ...... x ....................
//   StopOrder ....................... o .............. o ...
//   JourneyPatternCode ............................... x ...
//   TimingLinkOrder .................................. o ...
//   UserStopCode .................... o .............. o ...
//   --------------------------------------------------------
//
//   Legend:
//     x - Mandatory. The Notice for this object type is always depndent on the
//         value of the attribute.
//     o - Optional. The Notice can be independent of the value of this
//         attribute for this object type.
//     <empty> - Attribute is no key field for this object type and can be
//         ignored when processed.
//
// Usage of Notice Assignment is optional in KV1. If there are no clarifying
// texts, then the Notice Assignment table is not required to be present in the
// provided KV1 set.
//
// This table is part of the core data tables, which are common for all KV1
// variants.
struct Kv1NoticeAssignment {
  // Mandatory, at most 10 characters. Transport operator (from list as
  // defined in BISON enumeration E1).
  std::string data_owner_code;
  // Mandatory, at most 20 characters. Notice that is assigned.
  std::string notice_code;
  // Mandatory, at most 8 characters. Object type to which Notice is assigned.
  std::string assigned_object;
  // Optional, at most 10 characters. Only relevant for PUJO.
  std::string timetable_version_code;
  // Optional, at most 10 characters. Only relevant for PUJO and PUJOPASS.
  std::string organizational_unit_code;
  // Optional, at most 10 characters. Only relevant for PUJOPASS.
  std::string schedule_code;
  // Optional, at most 10 characters. Only relevant for PUJOPASS.
  std::string schedule_type_code;
  // Optional, at most 10 characters. Only relevant for PUJO.
  std::string period_group_code;
  // Optional, at most 10 characters. Only relevant for PUJO.
  std::string specific_day_code;
  // Optional, at most 10 characters. Only relevant for PUJO.
  // [0|1][0|2][0|3][0|4][0|5][0|6][0|7] for Mon, Tue, Wed, Thu, Fri, Sat, Sun.
  // E.g. 1234500 means Mon, Tue, Wed, Thu, Fri but not Sat, Sun.
  std::string day_type;
  // Mandatory, at most 10 characters. Mandatory for all object types.
  std::string line_planning_number;
  // Optional (for all object types except PUJO and PUJOPASS), at most 6
  // digits. Only relevant for PUJO and PUJOPASS. Must be in the range
  // [0-1000000).
  std::optional<int> journey_number;
  // Optional, at most 4 digits. Only relevant for PUJOPASS and JOPATILI.
  std::optional<int> stop_order;
  // Optional (for all object types except JOPATILI), at most 4 digits. Only
  // relevant for JOPATILI.
  std::string journey_pattern_code;
  // Optional (at most 3 digits). Only relevant for JOPATILI.
  std::optional<short> timing_link_order;
  // Optional (at most 10 characters). Only relevant for PUJOPASS and JOPATILI.
  // For JOPATILI, this correspond to the first stop of the link.
  std::string user_stop_code;

  Kv1Notice *p_notice = nullptr;
};

// KV1 Table 19: Time Demand Group [TIMDEMGRP]
//
// A time demand group is a grouping of the run time distribution from stop to
// stop, for a journey pattern (from start to end point).
//
// This table is part of the KV1 variant "validities and time demand groups".
struct Kv1TimeDemandGroup {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string line_planning_number;
    // Mandatory (key), at most 10 characters. Refers to the JOPATILI table.
    std::string journey_pattern_code;
    // Mandatory (key), at most 10 characters. Defines the code for the time
    // demand group. (NOTE: this is not entirely made clear by the specification.
    // This claim must be verified.)
    std::string time_demand_group_code;

    explicit Key(std::string data_owner_code,
                 std::string line_planning_number,
                 std::string journey_pattern_code,
                 std::string time_demand_group_code);
  };

  Key key;

  Kv1Line           *p_line            = nullptr;
  Kv1JourneyPattern *p_journey_pattern = nullptr;
};

// KV1 Table 20: Time Demand Group Run Time [TIMDEMRNT]
//
// The run time structure/distribution for all timing links of a journey
// pattern or a time demand group.
//
// Optional run time elements are, when these are present, used to more
// accurately calculate expected departure times based on punctuality
// deviations.
//
// This table is part of the KV1 variant "validities and time demand groups".
struct Kv1TimeDemandGroupRunTime {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string line_planning_number;
    // Mandatory (key), at most 10 characters. Refers to the JOPATILI table.
    std::string journey_pattern_code;
    // Mandatory (key), at most 10 characters. Refers to the TIMDEMGRP table.
    std::string time_demand_group_code;
    // Mandatory (key), at most 3 digits. Reference number of a link within the
    // journey pattern (a link can occur more than once within a journey
    // pattern).
    short timing_link_order = 0;

    explicit Key(std::string data_owner_code,
                 std::string line_planning_number,
                 std::string journey_pattern_code,
                 std::string time_demand_group_code,
                 short timing_link_order);
  };

  Key key;
  // Mandatory, at most 10 characters. Refers to the first stop of the link.
  std::string user_stop_code_begin;
  // Mandatory, at most 10 characters. Refers to the last stop of the link.
  std::string user_stop_code_end;
  // Mandatory, at most 5 digits. Planned total run time on link for time
  // demand group: (Departure time end stop - departure time begin stop)
  // corresponding to the time demand group. In seconds.
  double total_drive_time_s = 0;
  // Mandatory, at most 5 digits. Planned minimal run time on link for time
  // demand group. Often calculated as: (Arrival time end stop - arrival time
  // begin stop) corresponding to the time demand group. In seconds.
  double drive_time_s = 0;
  // Optional, at most 5 digits. Expected/planned delay/congestion on link for
  // time demand group. In seconds.
  std::optional<double> expected_delay_s;
  // Optional, at most 5 digits. Layover/catch-up time. Gives play in the
  // timetable. In seconds.
  //   LayOverTime = TotDriveTime - DriveTime + ExpectedDelay - StopWaitTime. 
  std::optional<double> layover_time;
  // Mandatory, at most 5 digits. Planned stop waiting time at the final stop
  // of the link for the time demand group. Determined based on the difference
  // between the departure time and arrival time at this stop. Is zero when no
  // waiting time is planned for this stop. In seconds.
  double stop_wait_time = 0;
  // Optional, at most 5 digits. Planned minimal stop time for
  // boarding/alighting of passengers at the final stop of the link for the
  // time demand group. Application: at hub stops with a planned waiting time,
  // the difference between the planned waiting time and the minimum stop time
  // is the layover/catch-up time. In seconds.
  std::optional<double> minimum_stop_time;

  Kv1Line                     *p_line                        = nullptr;
  Kv1UserStopPoint            *p_user_stop_begin             = nullptr;
  Kv1UserStopPoint            *p_user_stop_end               = nullptr;
  Kv1JourneyPattern           *p_journey_pattern             = nullptr;
  Kv1TimeDemandGroup          *p_time_demand_group           = nullptr;
  Kv1JourneyPatternTimingLink *p_journey_pattern_timing_link = nullptr;
};

// KV1 Table 21: Period Group [PEGR]
//
// Period group is an indication of a 'homogeneous period' during the year,
// i.e. a period in which the schedule has the same composition w.r.t.
// frequencies and run times.
//
// This table is part of the KV1 variant "validities and time demand groups".
struct Kv1PeriodGroup {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string period_group_code;

    explicit Key(std::string data_owner_code,
                 std::string period_group_code);
  };

  Key key;
  // Optional, at most 255 characters.
  std::string description;
};

// KV1 Table 22: Specific Day [SPECDAY]
//
// A specific day is a feature of a day for which a deviating service level is
// provided, respective to a normal day of the week.
//
// E.g. shopping Sundays (koopzondagen, if not every Sunday), New Year's Eve
// (oudejaarsdag), foreign bank holidays (as applicable).
//
// This table is part of the KV1 variant "validities and time demand groups".
struct Kv1SpecificDay {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Default: "NORMAL".
    std::string specific_day_code;

    explicit Key(std::string data_owner_code,
                 std::string specific_day_code);
  };

  Key key;
  // Mandatory, at most 50 characters.
  std::string name;
  // Optional, at most 255 characters.
  std::string description;
};

// KV1 Table 23: Timetable Version [TIVE]
//
// A timetable version budles all planned activities for an organizational
// unit. For the public schedule, these are trips, routes, run times etc.
//
// When processing a new Timetable Version, it is checked if another TIVE with
// the same key has already been processed. If this is the case, ValidFrom must
// be equal to the starting date of the previously provided set. The new set
// replaces the older one. A package with a new starting date is only processed
// if another TimetableVersionCode is used.
//
// This table is part of the KV1 variant "validities and time demand groups".
struct Kv1TimetableVersion {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string organizational_unit_code;
    // Mandatory (key), at most 10 characters.
    std::string timetable_version_code;
    // Mandatory (key), at most 10 charactes.
    std::string period_group_code;
    // Mandatory (key), at most 10 characters. Default: "NORMAL".
    std::string specific_day_code;

    explicit Key(std::string data_owner_code,
                 std::string organizational_unit_code,
                 std::string timetable_version_code,
                 std::string period_group_code,
                 std::string specific_day_code);
  };

  Key key;
  // Mandatory, at most 10 characters. Datum on which the timetable goes into
  // effect, following the YYYY-MM-DD format.
  std::chrono::year_month_day valid_from;
  // Mandatory, at most 10 characters. Value: "PUBT".
  std::string timetable_version_type;
  // Optional, at most 10 characters. Datum on which the timetable goes out of
  // effect, following the YYYY-MM-DD format.
  std::optional<std::chrono::year_month_day> valid_thru;
  // Optional, at most 255 characters. Should be null/empty.
  std::string description;

  Kv1OrganizationalUnit *p_organizational_unit = nullptr;
  Kv1PeriodGroup        *p_period_group        = nullptr;
  Kv1SpecificDay        *p_specific_day        = nullptr;
};

// KV1 Table 24: Public Journey [PUJO]
//
// Public journeys are journeys that are operated by a public transit
// organization and are accessible to the passenger.
//
// Business rules:
//   - If ShowFlexibleTrip or ProductFormulaType is set in a record of this
//     table, this takes precedence over the value as in the corresponding
//     JOPATILI entry.
//
// This table is part of the KV1 variant "validities and time demand groups".
struct Kv1PublicJourney {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string timetable_version_code;
    // Mandatory (key), at most 10 characters.
    std::string organizational_unit_code;
    // Mandatory (key), at most 10 characters.
    std::string period_group_code;
    // Mandatory (key), at most 10 characters.
    std::string specific_day_code;
    // Mandatory (key), at most 7 characters.
    // [0|1][0|2][0|3][0|4][0|5][0|6][0|7] for Mon, Tue, Wed, Thu, Fri, Sat, Sun.
    // E.g. 1234500 means Mon, Tue, Wed, Thu, Fri but not Sat, Sun.
    // TODO: See if we can make this into a more concrete type
    std::string day_type;
    // Mandatory (key), at most 10 characters.
    std::string line_planning_number;
    // Mandatory (key), at most 6 digits. Must be in the range [0-1000000).
    int journey_number = 0;

    explicit Key(std::string data_owner_code,
                 std::string timetable_version_code,
                 std::string organizational_unit_code,
                 std::string period_group_code,
                 std::string specific_day_code,
                 std::string day_type,
                 std::string line_planning_number,
                 int journey_number);
  };

  Key key;
  // Mandatory, at most 10 characters.
  std::string time_demand_group_code;
  // Mandatory, at most 10 characters.
  std::string journey_pattern_code;
  // Mandatory, at most 8 characters. Format: "HH:MM:SS".
  std::chrono::hh_mm_ss<std::chrono::seconds> departure_time;
  // Mandatory, at most 13 characters. Values as in BISON enumeration E3.
  // Allowed are: "ACCESSIBLE", "NOTACCESSIBLE" and "UNKNOWN".
  // TODO: See if we can fit BISON enumeration E3 into an enum
  std::string wheelchair_accessible;
  // Mandatory, at most 5 characters. Boolean. Value "true": journey is
  // operator by DataOwner. Value "false": journey is operator by a different
  // DataOwner. Indicator is meant for a line that is operated jointly by
  // multiple transit operators. The indicator is used to be able to match the
  // journey operation (KV6, KV19 etc.); only journeys for which the indicator
  // is "true" can be expected to have corresponding current/real-time
  // information, although "true" doesn't necessarily mean that this
  // current/real-time information will (always) become available.
  bool data_owner_is_operator = false;
  // Mandatory, at most 5 characters. Boolean. Indicates whether
  // current/real-time journey information may be expected for the
  // corresponding journey ("true" or "false").
  bool planned_monitored = false;
  // Optional, at most 4 digits. BISON enumeration E10. Intended to allow
  // capturing transit mode features at the journey level.
  // TODO: See if we can make BISON enumeration E10 into an enum
  std::optional<short> product_formula_type;
  // Optional, at most 8 characters. Indicates whether the transit operator
  // wants that a not-explicitly planned trip (i.e. a journey that only runs on
  // reservation, e.g. 'call bus' (belbus), 'line taxi' (lijntaxi) etc.) to be
  // shown on displays. Values following BISON enumeration E21: TRUE (always),
  // FALSE (never), REALTIME (only when journey is tracked).
  // TODO: See if we can make BISON enumeration E21 into an enum
  std::string show_flexible_trip;

  Kv1TimetableVersion   *p_timetable_version   = nullptr;
  Kv1OrganizationalUnit *p_organizational_unit = nullptr;
  Kv1PeriodGroup        *p_period_group        = nullptr;
  Kv1SpecificDay        *p_specific_day        = nullptr;
  Kv1Line               *p_line                = nullptr;
  Kv1TimeDemandGroup    *p_time_demand_group   = nullptr;
  Kv1JourneyPattern     *p_journey_pattern     = nullptr;
};

// KV1 Table 25: Period Group Validity [PEGRVAL]
//
// Validities (multiple from-thru data) of a period group.
//
// This table is part of the KV1 variant "validities and time demand groups".
struct Kv1PeriodGroupValidity {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string organizational_unit_code;
    // Mandatory (key), at most 10 characters.
    std::string period_group_code;
    // Mandatory (key), at most 10 characters. Date of the start of the validity
    // period. Format: "YYYY-MM-DD".
    std::chrono::year_month_day valid_from;

    explicit Key(std::string data_owner_code,
                 std::string organizational_unit_code,
                 std::string period_group_code,
                 std::chrono::year_month_day valid_from);
  };

  Key key;
  // Mandatory, at most 10 characters. Date of the end of the validity period.
  // Format: "YYYY-MM-DD".
  std::chrono::year_month_day valid_thru;

  Kv1OrganizationalUnit *p_organizational_unit = nullptr;
  Kv1PeriodGroup        *p_period_group        = nullptr;
};

// KV1 Table 26: Exceptional Operating Day [EXCOPDAY]
//
// Contains exceptional validity dates, for which the service runs following a
// different day type (such as another day of the week or a different period).
//
// This table is part of the KV1 variant "validities and time demand groups".
struct Kv1ExceptionalOperatingDay {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters. Organization unit for which an
    // exceptional day validity applies.
    std::string organizational_unit_code;
    // Mandatory (key), at most 23 characters. Date (+ time) for which the
    // exceptional validity applies. Format: "YYYYMMDDThh:mm:ssTZD".
    std::chrono::sys_seconds valid_date;

    explicit Key(std::string data_owner_code,
                 std::string organizational_unit_code,
                 std::chrono::sys_seconds valid_date);
  };

  Key key;
  // Mandatory, at most 7 characters. The exceptional day type that applies on
  // a calendar day: [0|1][0|2][0|3][0|4][0|5][0|6][0|7] for Mon, Tue, Wed,
  // Thu, Fri, Sat.
  // E.g. 1234500 means Mon, Tue, Wed, Thu, Fri but not Sat, Sun.
  // TODO: See if we can make this into a more concrete type
  std::string day_type_as_on;
  // Mandatory, at most 10 characters. Specific day service level to which the
  // exceptional day validity refers.
  std::string specific_day_code;
  // Optional, at most 10 characters. An exceptional day validity can be
  // related to the service level of another period (e.g. the school holiday
  // schedule). This exceptional period reference is set here.
  // 
  // E.g. on Good Friday or the day after Ascension day, transit runs according
  // to the holiday season schedule, while transit runs following the winter
  // package in the surrounding days.
  std::string period_group_code;
  // Optional, at most 255 characters.
  std::string description;

  Kv1OrganizationalUnit *p_organizational_unit = nullptr;
  Kv1SpecificDay        *p_specific_day        = nullptr;
  Kv1PeriodGroup        *p_period_group        = nullptr;
};

// KV1 Table 27: Schedule Version [SCHEDVERS]
//
// A schedule version bundles the planned activities for an organisation unit
// per day type. The journeys with passing times and corresponding routes are
// for the public timetable.
//
// When processing a new Schedule Version, it is checked if another SCHEDVERS
// with the same key has already been processed. If this is the case, ValidFrom
// must be equal to the starting date of the previously provided set. The new
// set replaces the older one. A package with a new starting date is only
// processed if another Schedule Code is used.
//
// This table is part of the KV1 variant "schedules and passing times".
struct Kv1ScheduleVersion {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string organizational_unit_code;
    // Mandatory (key), at most 10 characters. A unique code in combination with
    // the ScheduleTypeCode of the package within the ORUN.
    std::string schedule_code;
    // Mandatory (key), at most 10 characters. Code for the Schedule Type (Day Type).
    std::string schedule_type_code;

    explicit Key(std::string data_owner_code,
                 std::string organizational_unit_code,
                 std::string schedule_code,
                 std::string schedule_type_code);
  };

  Key key;
  // Mandatory, at most 10 characters. Date on which the schedule goes into
  // effect. Format: "YYYY-MM-DD".
  std::chrono::year_month_day valid_from;
  // Optional, at most 10 characters. Date on which the schedule goes out of
  // effect. Format: "YYYY-MM-DD".
  std::optional<std::chrono::year_month_day> valid_thru;
  // Optional, at most 255 characters. Should be empty/null.
  std::string description;

  Kv1OrganizationalUnit *p_organizational_unit = nullptr;
};

// KV1 Table 28: Public Journey Passing Times [PUJOPASS]
//
// Public journey with arrival and departure times at all stops (and other
// timing points).
//
// Business rules:
//   - If ShowFlexibleTrip or ProductFormulaType is set here, then this takes
//     precedence over the value in the corresponding JOPATILI record.
//   - All stop passings of a public journey refer to the same journey pattern
//     (JOPA)!
//
// This table is part of the KV1 variant "schedules and passing times".
struct Kv1PublicJourneyPassingTimes {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string organizational_unit_code;
    // Mandatory (key), at most 10 characters. A unique code in combination with
    // the ScheduleTypeCode of the package within the ORUN.
    std::string schedule_code;
    // Mandatory (key), at most 10 characters. Code for the Schedule Type (e.g.
    // Day Type).
    std::string schedule_type_code;
    // Mandatory (key), at most 10 characters.
    std::string line_planning_number;
    // Mandatory (key), at most 6 digits. Must be in the range [0-1000000).
    int journey_number = 0;
    // Mandatory (key), at most 4 digits.
    short stop_order = 0;

    explicit Key(std::string data_owner_code,
                 std::string organizational_unit_code,
                 std::string schedule_code,
                 std::string schedule_type_code,
                 std::string line_planning_number,
                 int journey_number,
                 short stop_order);
  };

  Key key;
  // Mandatory, at most 10 characters.
  std::string journey_pattern_code;
  // Mandatory, at most 10 characters.
  std::string user_stop_code;
  // Mandatory (except for the first stop of a journey), at most 8 digits. Not
  // compulsory for the first stop of a journey. Format: "HH:MM:SS".
  std::optional<std::chrono::hh_mm_ss<std::chrono::seconds>> target_arrival_time;
  // Mandatory (expect for the last stop of a journey), at most 8 digits. Not
  // compulsory for the last stop of a journey. Format: "HH:MM:SS".
  std::optional<std::chrono::hh_mm_ss<std::chrono::seconds>> target_departure_time;
  // Mandatory, at most 13 characters. Values as in BISON enumeration E3.
  // Allowed are: "ACCESSIBLE", "NOTACCESSIBLE" and "UNKNOWN".
  // TODO: See if we can fit BISON enumeration E3 into an enum
  std::string wheelchair_accessible;
  // Mandatory, at most 5 characters. Boolean. Value "true": journey is
  // operator by DataOwner. Value "false": journey is operator by a different
  // DataOwner. Indicator is meant for a line that is operated jointly by
  // multiple transit operators. The indicator is used to be able to match the
  // journey operation (KV6, KV19 etc.); only journeys for which the indicator
  // is "true" can be expected to have corresponding current/real-time
  // information, although "true" doesn't necessarily mean that this
  // current/real-time information will (always) become available.
  bool data_owner_is_operator = false;
  // Mandatory, at most 5 characters. Boolean. Indicates whether
  // current/real-time journey information may be expected for the
  // corresponding journey ("true" or "false").
  bool planned_monitored = false;
  // Optional, at most 4 digits. BISON enumeration E10. Intended to allow
  // capturing transit mode features at the journey level.
  // TODO: See if we can make BISON enumeration E10 into an enum
  std::optional<short> product_formula_type;
  // Optional, at most 8 characters. Indicates whether the transit operator
  // wants that a not-explicitly planned trip (i.e. a journey that only runs on
  // reservation, e.g. 'call bus' (belbus), 'line taxi' (lijntaxi) etc.) to be
  // shown on displays. Values following BISON enumeration E21: TRUE (always),
  // FALSE (never), REALTIME (only when journey is tracked).
  // TODO: See if we can make BISON enumeration E21 into an enum
  std::string show_flexible_trip;

  Kv1OrganizationalUnit *p_organizational_unit = nullptr;
  Kv1ScheduleVersion    *p_schedule_version    = nullptr;
  Kv1Line               *p_line                = nullptr;
  Kv1JourneyPattern     *p_journey_pattern     = nullptr;
  Kv1UserStopPoint      *p_user_stop           = nullptr;
};

// KV1 Table 29: Operating Day [OPERDAY]
//
// Contains the operational calendar. Which package (schedule version) applies
// is specified per day, per organisation unit.
//
// This table is part of the KV1 variant "schedules and passing times".
struct Kv1OperatingDay {
  struct Key {
    // Mandatory (key), at most 10 characters. Transport operator (from list as
    // defined in BISON enumeration E1).
    std::string data_owner_code;
    // Mandatory (key), at most 10 characters.
    std::string organizational_unit_code;
    // Mandatory (key), at most 10 characters.
    std::string schedule_code;
    // Mandatory (key), at most 10 characters.
    std::string schedule_type_code;
    // Mandatory (key), at most 10 characters. Date on which the package
    // (schedule version) applies. Format: "YYYY-MM-DD".
    std::chrono::year_month_day valid_date;

    explicit Key(std::string data_owner_code,
                 std::string organizational_unit_code,
                 std::string schedule_code,
                 std::string schedule_type_code,
                 std::chrono::year_month_day valid_date);
  };

  Key key;
  // Optional, at most 255 characters.
  std::string description;

  Kv1OrganizationalUnit *p_organizational_unit = nullptr;
  Kv1ScheduleVersion    *p_schedule_version    = nullptr;
};

bool operator==(const Kv1OrganizationalUnit::Key &a, const Kv1OrganizationalUnit::Key &b);
bool operator==(const Kv1HigherOrganizationalUnit::Key &a, const Kv1HigherOrganizationalUnit::Key &b);
bool operator==(const Kv1UserStopPoint::Key &a, const Kv1UserStopPoint::Key &b);
bool operator==(const Kv1UserStopArea::Key &a, const Kv1UserStopArea::Key &b);
bool operator==(const Kv1TimingLink::Key &a, const Kv1TimingLink::Key &b);
bool operator==(const Kv1Link::Key &a, const Kv1Link::Key &b);
bool operator==(const Kv1Line::Key &a, const Kv1Line::Key &b);
bool operator==(const Kv1Destination::Key &a, const Kv1Destination::Key &b);
bool operator==(const Kv1JourneyPattern::Key &a, const Kv1JourneyPattern::Key &b);
bool operator==(const Kv1ConcessionFinancerRelation::Key &a, const Kv1ConcessionFinancerRelation::Key &b);
bool operator==(const Kv1ConcessionArea::Key &a, const Kv1ConcessionArea::Key &b);
bool operator==(const Kv1Financer::Key &a, const Kv1Financer::Key &b);
bool operator==(const Kv1JourneyPatternTimingLink::Key &a, const Kv1JourneyPatternTimingLink::Key &b);
bool operator==(const Kv1Point::Key &a, const Kv1Point::Key &b);
bool operator==(const Kv1PointOnLink::Key &a, const Kv1PointOnLink::Key &b);
bool operator==(const Kv1Icon::Key &a, const Kv1Icon::Key &b);
bool operator==(const Kv1Notice::Key &a, const Kv1Notice::Key &b);
bool operator==(const Kv1TimeDemandGroup::Key &a, const Kv1TimeDemandGroup::Key &b);
bool operator==(const Kv1TimeDemandGroupRunTime::Key &a, const Kv1TimeDemandGroupRunTime::Key &b);
bool operator==(const Kv1PeriodGroup::Key &a, const Kv1PeriodGroup::Key &b);
bool operator==(const Kv1SpecificDay::Key &a, const Kv1SpecificDay::Key &b);
bool operator==(const Kv1TimetableVersion::Key &a, const Kv1TimetableVersion::Key &b);
bool operator==(const Kv1PublicJourney::Key &a, const Kv1PublicJourney::Key &b);
bool operator==(const Kv1PeriodGroupValidity::Key &a, const Kv1PeriodGroupValidity::Key &b);
bool operator==(const Kv1ExceptionalOperatingDay::Key &a, const Kv1ExceptionalOperatingDay::Key &b);
bool operator==(const Kv1ScheduleVersion::Key &a, const Kv1ScheduleVersion::Key &b);
bool operator==(const Kv1PublicJourneyPassingTimes::Key &a, const Kv1PublicJourneyPassingTimes::Key &b);
bool operator==(const Kv1OperatingDay::Key &a, const Kv1OperatingDay::Key &b);

size_t hash_value(const Kv1OrganizationalUnit::Key &k);
size_t hash_value(const Kv1HigherOrganizationalUnit::Key &k);
size_t hash_value(const Kv1UserStopPoint::Key &k);
size_t hash_value(const Kv1UserStopArea::Key &k);
size_t hash_value(const Kv1TimingLink::Key &k);
size_t hash_value(const Kv1Link::Key &k);
size_t hash_value(const Kv1Line::Key &k);
size_t hash_value(const Kv1Destination::Key &k);
size_t hash_value(const Kv1JourneyPattern::Key &k);
size_t hash_value(const Kv1ConcessionFinancerRelation::Key &k);
size_t hash_value(const Kv1ConcessionArea::Key &k);
size_t hash_value(const Kv1Financer::Key &k);
size_t hash_value(const Kv1JourneyPatternTimingLink::Key &k);
size_t hash_value(const Kv1Point::Key &k);
size_t hash_value(const Kv1PointOnLink::Key &k);
size_t hash_value(const Kv1Icon::Key &k);
size_t hash_value(const Kv1Notice::Key &k);
size_t hash_value(const Kv1TimeDemandGroup::Key &k);
size_t hash_value(const Kv1TimeDemandGroupRunTime::Key &k);
size_t hash_value(const Kv1PeriodGroup::Key &k);
size_t hash_value(const Kv1SpecificDay::Key &k);
size_t hash_value(const Kv1TimetableVersion::Key &k);
size_t hash_value(const Kv1PublicJourney::Key &k);
size_t hash_value(const Kv1PeriodGroupValidity::Key &k);
size_t hash_value(const Kv1ExceptionalOperatingDay::Key &k);
size_t hash_value(const Kv1ScheduleVersion::Key &k);
size_t hash_value(const Kv1PublicJourneyPassingTimes::Key &k);
size_t hash_value(const Kv1OperatingDay::Key &k);

#endif // OEUF_LIBTMI8_KV1_TYPES_HPP