Attack = ref object
  length*: float             ## For how long the attack is active
  mods*: seq[string]         ## The modifiers which will be applied
  

BackgroundChange = ref object
  beat*: float               ## The beat on which the change occurs
  path*: string              ## The file path (or if it's a folder path, uses "default.lua") to the script file
  updateRate*: float         ## How often the change is updated
  crossFade*: bool           ## If it should use the cross-fade effect (overruled by `effect`)
  stretchRewind*: bool       ## If it should use the stretch-rewind effect (overruled by `effect`)
  stretchNoLoop*: bool       ## If it should use the stretch-noloop effect (overruled by `effect`)
  effect*: string            ## The background-effect to use
  file2*: string             ## The second file to load/use
  transition*: string        ## The the background transitions to this state
  color1*: Color             ## First color passed to the script files
  color2*: Color             ## Second color passed to the script files
  

BpmChange = ref object
  beat*: float               ## At which beat the change occurs
  bpm*: float                ## To what BPM it should change
  

ChartType {.pure.} = enum
  DanceSingle = "dance-single", ## 4k - 4k in single-player
  DanceDouble = "dance-double", ## 8k - 4k with 2 pads in single-player
  DanceCouple = "dance-couple", ## 8k - 4k with 2 pads for 2 people
  DanceRoutine = "dance-routine", ## 8k - 4k with 2 pads where players rotate
  DanceSolo = "dance-solo", ## 6k - 6k in single-player
  PumpSingle = "pump-single", ## 5k - 5k in single-player
  PumpHalfdouble = "pump-halfdouble", ## 6k - 5k with 2 pads in single-player, but only inner arrows
  PumpDouble = "pump-double", ## 10k - 5k with 2 pads in single-player
  PumpCouple = "pump-couple" ## 10k - 5k with 2 pads for 2 people

Color = array[4, float]

ComboChange = ref object
  beat*: float               ## When the combo-change should occur
  hit*: int                  ## How much a single hit should count to the combo
  miss*: int                 ## How many misses a single miss should count
  

Delay = ref object
  beat*: float               ## At which beat the delay occurs
  duration*: float           ## For how long the delay holds on
  

Difficulty {.pure.} = enum
  Beginner = "beginner", Easy = "easy", Medium = "medium", Hard = "hard",
  Challenge = "challenge", Edit = "edit"

FakeSection = ref object
  beat*: float               ## The beat from when the fake-section should begin from
  duration*: float           ## How long the fake-section should last (in beats)
  

InstrumentTrack = ref object
  instrument*: string        ## The instrument name
  file*: string              ## The file-path to the track/song
  

Label = ref object
  beat*: float               ## The beat on which the label is placed on
  content*: string           ## The text/content of the label
  

Modifier = ref object
  name*: string              ## The name of the modifier
  player*: string            ## The player for which the modifier is meant for
  approachRate*: int         ## The approach-rate
  magnitude*: float          ## The magnitude of the modifier
  isPercent*: bool           ## If the '_magnitude is percent based
  

RadarValues = array[5, float]

ScollSpeedChange = ref object
  beat*: float               ## The beat where the scroll-speed occurs on
  factor*: float             ## The factor of how much the scoll changes compared to the regular speed
  

SpeedChange = ref object
  beat*: float               ## The beat where the speed-change occurs on
  ratio*: float              ## The ratio that will be applied
  duration*: float           ## How long it should take for the ratio to be applied (will be applied gradually)
  inSeconds*: bool           ## If the duration is specified in seconds or in beats
  

Stop = ref object
  beat*: float               ## At which beat the stop occurs
  duration*: float           ## For how long the stop holds on
  

TickCount = ref object
  beat*: float               ## At which beat the tick-count changes
  count*: int                ## How many ticks it should change to
  

TimedAttack = ref object
  length*: float             ## For how long the attack is active
  mods*: seq[Modifier]       ## The modifiers which will be applied
  time*: float               ## The time when the attack occurs
  

TimeSignature = ref object
  beat*: float               ## At which point the time-signature changes
  numerator*: int            ## The numerator of the signature
  denominator*: int          ## The deniminator of the signature
  

func `$`(ct: ChartType): string {....raises: [], tags: [].}

func `$`(diff: Difficulty): string {....raises: [], tags: [].}

proc boolFlag(val: bool): string {....raises: [], tags: [].}

func columnCount(mode: ChartType): int {....raises: [], tags: [].}

func newAttack(length: float = 0.0; mods: seq[string] = @[]): Attack {.
    ...raises: [], tags: [].}

func newBackgroundChange(beat: float = 0.0; path: string = "";
                         updateRate: float = 0.0; crossFade: bool = false;
                         stretchRewind: bool = false;
                         stretchNoLoop: bool = false; effect: string = "";
                         file2: string = ""; transition: string = "";
                         color1: Color = [0.0, 0.0, 0.0, 0.0];
                         color2: Color = [0.0, 0.0, 0.0, 0.0]): BackgroundChange {.
    ...raises: [], tags: [].}

func newBpmChange(beat: float; bpm: float): BpmChange {....raises: [], tags: [].}

func newBpmChange(beat: Option[float]; bpm: Option[float]): BpmChange {.
    ...raises: [], tags: [].}

func newComboChange(beat: float; hit: int; miss: int): ComboChange {....raises: [],
    tags: [].}

func newComboChange(beat: Option[float]; hit: Option[int]; miss: Option[int]): ComboChange {.
    ...raises: [], tags: [].}

func newDelay(beat: float; duration: float): Delay {....raises: [], tags: [].}

func newDelay(beat: Option[float]; duration: Option[float]): Delay {....raises: [],
    tags: [].}

func newFakeSection(beat: float; duration: float): FakeSection {....raises: [],
    tags: [].}

func newFakeSection(beat: Option[float]; duration: Option[float]): FakeSection {.
    ...raises: [], tags: [].}

func newInstrumentTrack(instrument: string = ""; file: string = ""): InstrumentTrack {.
    ...raises: [], tags: [].}

func newLabel(beat: float = 0.0; content: string = ""): Label {....raises: [],
    tags: [].}

func newModifier(name: string; player: string = ""; approachRate: int = 1;
                 magnitude: float = 100; isPercent: bool = true): Modifier {.
    ...raises: [], tags: [].}

func newScollSpeedChange(beat: float; factor: float): ScollSpeedChange {.
    ...raises: [], tags: [].}

func newScollSpeedChange(beat: Option[float]; factor: Option[float]): ScollSpeedChange {.
    ...raises: [], tags: [].}

func newSpeedChange(beat: float; ratio: float; duration: float; inSeconds: bool): SpeedChange {.
    ...raises: [], tags: [].}

func newSpeedChange(beat: Option[float]; ratio: Option[float];
                    duration: Option[float]; inSeconds: Option[bool]): SpeedChange {.
    ...raises: [], tags: [].}

func newStop(beat: float; duration: float): Stop {....raises: [], tags: [].}

func newStop(beat: Option[float]; duration: Option[float]): Stop {....raises: [],
    tags: [].}

func newTickCount(beat: float; count: int): TickCount {....raises: [], tags: [].}

func newTickCount(beat: Option[float]; count: Option[int]): TickCount {.
    ...raises: [], tags: [].}

func newTimeSignature(beat: float; numerator: int; denominator: int): TimeSignature {.
    ...raises: [], tags: [].}

func newTimeSignature(beat: Option[float]; numerator: Option[int];
                      denominator: Option[int]): TimeSignature {....raises: [],
    tags: [].}

func parseAttack(data: string): Attack {....raises: [], tags: [].}

func parseBackgroundChanges(data: string): seq[BackgroundChange] {....raises: [],
    tags: [].}

func parseBpms(data: string): seq[BpmChange] {....raises: [], tags: [].}

func parseColor(data: string): Color {....raises: [], tags: [].}

func parseComboChanges(data: string): seq[ComboChange] {....raises: [], tags: [].}

func parseDelays(data: string): seq[Delay] {....raises: [], tags: [].}

func parseFakeSections(data: string): seq[FakeSection] {....raises: [], tags: [].}

func parseIntrumentTracks(data: string): seq[InstrumentTrack] {....raises: [],
    tags: [].}

func parseLabels(data: string): seq[Label] {....raises: [ValueError], tags: [].}

func parseModifier(data: string): Modifier {....raises: [], tags: [].}

func parseRadarValues(data: string): RadarValues {....raises: [], tags: [].}

func parseScollSpeedChanges(data: string): seq[ScollSpeedChange] {....raises: [],
    tags: [].}

func parseSpeedChanges(data: string): seq[SpeedChange] {....raises: [], tags: [].}

func parseStops(data: string): seq[Stop] {....raises: [], tags: [].}

func parseTickCounts(data: string): seq[TickCount] {....raises: [], tags: [].}

func parseTimeSignatures(data: string): seq[TimeSignature] {....raises: [],
    tags: [].}

proc putTag(str: var string; tag: string; value: string): void {.
    ...raises: [ValueError], tags: [].}

func splitByComma(data: string; doStrip: bool = false): seq[string] {.
    ...raises: [], tags: [].}

func write(attack: TimedAttack): string {....raises: [ValueError], tags: [].}

func write(change: BackgroundChange): string {....raises: [], tags: [].}

func write(color: Color): string {....raises: [], tags: [].}

func write(modi: Modifier): string {....raises: [ValueError], tags: [].}