-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | XML/XSD combinators/schemas/codegen
--   
--   Library for generating code from XML schema files, with MusicXml 3.1
--   schema library included. (2.0 and 3.0 can be also built with the
--   'build-old' cabal flag). Includes XML "combinator library" XParser for
--   consuming xml, a type model for XSD productions, a type model for
--   codegen, and the code generator.
@package fadno-xml
@version 1.2.1


-- | Emit an xml-like AST with renderers to String and <a>Element</a>.
--   Intended for use with generated code.
module Fadno.Xml.EmitXml

-- | render AST to String.
renderString :: XmlRep -> String

-- | render AST to Element.
renderElement :: XmlRep -> Element
renderFile :: EmitXml a => FilePath -> a -> IO ()

-- | Emit AST.
class EmitXml a
emitXml :: EmitXml a => a -> XmlRep

-- | XML AST.
data XmlRep
[XEmpty] :: XmlRep
[XLit] :: String -> XmlRep
[XShow] :: Show a => a -> XmlRep
[XElement] :: QN -> XmlRep -> XmlRep
[XAttr] :: QN -> XmlRep -> XmlRep
[XText] :: XmlRep -> XmlRep
[XContent] :: XmlRep -> [XmlRep] -> [XmlRep] -> XmlRep
[XReps] :: [XmlRep] -> XmlRep

-- | QName type.
data QN
QN :: String -> Maybe String -> QN
[qLocal] :: QN -> String
[qPrefix] :: QN -> Maybe String
instance GHC.Show.Show Fadno.Xml.EmitXml.XmlRep
instance Fadno.Xml.EmitXml.EmitXml a => Fadno.Xml.EmitXml.EmitXml (GHC.Maybe.Maybe a)
instance Fadno.Xml.EmitXml.EmitXml GHC.Base.String
instance Fadno.Xml.EmitXml.EmitXml a => Fadno.Xml.EmitXml.EmitXml [a]
instance Fadno.Xml.EmitXml.EmitXml GHC.Types.Int
instance Fadno.Xml.EmitXml.EmitXml Data.Decimal.Decimal
instance Fadno.Xml.EmitXml.EmitXml GHC.Types.Float
instance Fadno.Xml.EmitXml.EmitXml GHC.Types.Double
instance Fadno.Xml.EmitXml.EmitXml GHC.Types.Bool
instance GHC.Show.Show Fadno.Xml.EmitXml.QN


-- | Combinators over XML.
module Fadno.Xml.XParse

-- | Parsing monad.
newtype XParse a
XParse :: StateT Cursor (Except XErrors) a -> XParse a
[unXParse] :: XParse a -> StateT Cursor (Except XErrors) a

-- | Run monad.
runXParse :: Element -> XParse a -> Either XErrors a

-- | Parse failure.
xfail :: String -> XParse a

-- | Require <a>Just</a> a thing.
require :: String -> Maybe a -> XParse a

-- | Operate on attribute value/
xattr :: QName -> XParse String

-- | Operate on text.
xtext :: XParse String

-- | Consume a child element.
xchild :: QName -> XParse a -> XParse a

-- | Parse with <a>read</a>.
xread :: Read a => String -> String -> XParse a

-- | Operate on an element.
xel :: XParse Element

-- | Local name.
name :: String -> QName

-- | XSD name.
xsName :: String -> QName

-- | Convenience to read in top element from file.
readXml :: FilePath -> IO Element
instance GHC.Base.Alternative Fadno.Xml.XParse.XParse
instance Control.Monad.Error.Class.MonadError Fadno.Xml.XParse.XErrors Fadno.Xml.XParse.XParse
instance Control.Monad.State.Class.MonadState Text.XML.Light.Cursor.Cursor Fadno.Xml.XParse.XParse
instance GHC.Base.Monad Fadno.Xml.XParse.XParse
instance GHC.Base.Applicative Fadno.Xml.XParse.XParse
instance GHC.Base.Functor Fadno.Xml.XParse.XParse

module Fadno.MusicXml.MusicXml31

-- | <tt>xs:ID</tt> <i>(simple)</i>
newtype ID
ID :: NCName -> ID
[iD] :: ID -> NCName
parseID :: String -> XParse ID

-- | <tt>xs:IDREF</tt> <i>(simple)</i>
newtype IDREF
IDREF :: NCName -> IDREF
[iDREF] :: IDREF -> NCName
parseIDREF :: String -> XParse IDREF

-- | <tt>xs:NCName</tt> <i>(simple)</i>
newtype NCName
NCName :: Name -> NCName
[nCName] :: NCName -> Name
parseNCName :: String -> XParse NCName

-- | <tt>xs:NMTOKEN</tt> <i>(simple)</i>
newtype NMTOKEN
NMTOKEN :: Token -> NMTOKEN
[nMTOKEN] :: NMTOKEN -> Token
parseNMTOKEN :: String -> XParse NMTOKEN

-- | <tt>xs:Name</tt> <i>(simple)</i>
newtype Name
Name :: Token -> Name
[name] :: Name -> Token
parseName :: String -> XParse Name

-- | <tt>above-below</tt> <i>(simple)</i>
--   
--   The above-below type is used to indicate whether one element appears
--   above or below another element.
data AboveBelow

-- | <i>above</i>
AboveBelowAbove :: AboveBelow

-- | <i>below</i>
AboveBelowBelow :: AboveBelow
parseAboveBelow :: String -> XParse AboveBelow

-- | <tt>accidental-value</tt> <i>(simple)</i>
--   
--   The accidental-value type represents notated accidentals supported by
--   MusicXML. In the MusicXML 2.0 DTD this was a string with values that
--   could be included. The XSD strengthens the data typing to an
--   enumerated list. The quarter- and three-quarters- accidentals are
--   Tartini-style quarter-tone accidentals. The -down and -up accidentals
--   are quarter-tone accidentals that include arrows pointing down or up.
--   The slash- accidentals are used in Turkish classical music. The
--   numbered sharp and flat accidentals are superscripted versions of the
--   accidental signs, used in Turkish folk music. The sori and koron
--   accidentals are microtonal sharp and flat accidentals used in Iranian
--   and Persian music. The other accidental covers accidentals other than
--   those listed here. It is usually used in combination with the smufl
--   attribute to specify a particular SMuFL accidental. The smufl
--   attribute may be used with any accidental value to help specify the
--   appearance of symbols that share the same MusicXML semantics.
data AccidentalValue

-- | <i>sharp</i>
AccidentalValueSharp :: AccidentalValue

-- | <i>natural</i>
AccidentalValueNatural :: AccidentalValue

-- | <i>flat</i>
AccidentalValueFlat :: AccidentalValue

-- | <i>double-sharp</i>
AccidentalValueDoubleSharp :: AccidentalValue

-- | <i>sharp-sharp</i>
AccidentalValueSharpSharp :: AccidentalValue

-- | <i>flat-flat</i>
AccidentalValueFlatFlat :: AccidentalValue

-- | <i>natural-sharp</i>
AccidentalValueNaturalSharp :: AccidentalValue

-- | <i>natural-flat</i>
AccidentalValueNaturalFlat :: AccidentalValue

-- | <i>quarter-flat</i>
AccidentalValueQuarterFlat :: AccidentalValue

-- | <i>quarter-sharp</i>
AccidentalValueQuarterSharp :: AccidentalValue

-- | <i>three-quarters-flat</i>
AccidentalValueThreeQuartersFlat :: AccidentalValue

-- | <i>three-quarters-sharp</i>
AccidentalValueThreeQuartersSharp :: AccidentalValue

-- | <i>sharp-down</i>
AccidentalValueSharpDown :: AccidentalValue

-- | <i>sharp-up</i>
AccidentalValueSharpUp :: AccidentalValue

-- | <i>natural-down</i>
AccidentalValueNaturalDown :: AccidentalValue

-- | <i>natural-up</i>
AccidentalValueNaturalUp :: AccidentalValue

-- | <i>flat-down</i>
AccidentalValueFlatDown :: AccidentalValue

-- | <i>flat-up</i>
AccidentalValueFlatUp :: AccidentalValue

-- | <i>double-sharp-down</i>
AccidentalValueDoubleSharpDown :: AccidentalValue

-- | <i>double-sharp-up</i>
AccidentalValueDoubleSharpUp :: AccidentalValue

-- | <i>flat-flat-down</i>
AccidentalValueFlatFlatDown :: AccidentalValue

-- | <i>flat-flat-up</i>
AccidentalValueFlatFlatUp :: AccidentalValue

-- | <i>arrow-down</i>
AccidentalValueArrowDown :: AccidentalValue

-- | <i>arrow-up</i>
AccidentalValueArrowUp :: AccidentalValue

-- | <i>triple-sharp</i>
AccidentalValueTripleSharp :: AccidentalValue

-- | <i>triple-flat</i>
AccidentalValueTripleFlat :: AccidentalValue

-- | <i>slash-quarter-sharp</i>
AccidentalValueSlashQuarterSharp :: AccidentalValue

-- | <i>slash-sharp</i>
AccidentalValueSlashSharp :: AccidentalValue

-- | <i>slash-flat</i>
AccidentalValueSlashFlat :: AccidentalValue

-- | <i>double-slash-flat</i>
AccidentalValueDoubleSlashFlat :: AccidentalValue

-- | <i>sharp-1</i>
AccidentalValueSharp1 :: AccidentalValue

-- | <i>sharp-2</i>
AccidentalValueSharp2 :: AccidentalValue

-- | <i>sharp-3</i>
AccidentalValueSharp3 :: AccidentalValue

-- | <i>sharp-5</i>
AccidentalValueSharp5 :: AccidentalValue

-- | <i>flat-1</i>
AccidentalValueFlat1 :: AccidentalValue

-- | <i>flat-2</i>
AccidentalValueFlat2 :: AccidentalValue

-- | <i>flat-3</i>
AccidentalValueFlat3 :: AccidentalValue

-- | <i>flat-4</i>
AccidentalValueFlat4 :: AccidentalValue

-- | <i>sori</i>
AccidentalValueSori :: AccidentalValue

-- | <i>koron</i>
AccidentalValueKoron :: AccidentalValue

-- | <i>other</i>
AccidentalValueOther :: AccidentalValue
parseAccidentalValue :: String -> XParse AccidentalValue

-- | <tt>accordion-middle</tt> <i>(simple)</i>
--   
--   The accordion-middle type may have values of 1, 2, or 3, corresponding
--   to having 1 to 3 dots in the middle section of the accordion
--   registration symbol. This type is not used if no dots are present.
newtype AccordionMiddle
AccordionMiddle :: PositiveInteger -> AccordionMiddle
[accordionMiddle] :: AccordionMiddle -> PositiveInteger
parseAccordionMiddle :: String -> XParse AccordionMiddle

-- | <tt>xlink:actuate</tt> <i>(simple)</i>
data Actuate

-- | <i>onRequest</i>
ActuateOnRequest :: Actuate

-- | <i>onLoad</i>
ActuateOnLoad :: Actuate

-- | <i>other</i>
ActuateOther :: Actuate

-- | <i>none</i>
ActuateNone :: Actuate
parseActuate :: String -> XParse Actuate

-- | <tt>arrow-direction</tt> <i>(simple)</i>
--   
--   The arrow-direction type represents the direction in which an arrow
--   points, using Unicode arrow terminology.
data ArrowDirection

-- | <i>left</i>
ArrowDirectionLeft :: ArrowDirection

-- | <i>up</i>
ArrowDirectionUp :: ArrowDirection

-- | <i>right</i>
ArrowDirectionRight :: ArrowDirection

-- | <i>down</i>
ArrowDirectionDown :: ArrowDirection

-- | <i>northwest</i>
ArrowDirectionNorthwest :: ArrowDirection

-- | <i>northeast</i>
ArrowDirectionNortheast :: ArrowDirection

-- | <i>southeast</i>
ArrowDirectionSoutheast :: ArrowDirection

-- | <i>southwest</i>
ArrowDirectionSouthwest :: ArrowDirection

-- | <i>left right</i>
ArrowDirectionLeftRight :: ArrowDirection

-- | <i>up down</i>
ArrowDirectionUpDown :: ArrowDirection

-- | <i>northwest southeast</i>
ArrowDirectionNorthwestSoutheast :: ArrowDirection

-- | <i>northeast southwest</i>
ArrowDirectionNortheastSouthwest :: ArrowDirection

-- | <i>other</i>
ArrowDirectionOther :: ArrowDirection
parseArrowDirection :: String -> XParse ArrowDirection

-- | <tt>arrow-style</tt> <i>(simple)</i>
--   
--   The arrow-style type represents the style of an arrow, using Unicode
--   arrow terminology. Filled and hollow arrows indicate polygonal single
--   arrows. Paired arrows are duplicate single arrows in the same
--   direction. Combined arrows apply to double direction arrows like left
--   right, indicating that an arrow in one direction should be combined
--   with an arrow in the other direction.
data ArrowStyle

-- | <i>single</i>
ArrowStyleSingle :: ArrowStyle

-- | <i>double</i>
ArrowStyleDouble :: ArrowStyle

-- | <i>filled</i>
ArrowStyleFilled :: ArrowStyle

-- | <i>hollow</i>
ArrowStyleHollow :: ArrowStyle

-- | <i>paired</i>
ArrowStylePaired :: ArrowStyle

-- | <i>combined</i>
ArrowStyleCombined :: ArrowStyle

-- | <i>other</i>
ArrowStyleOther :: ArrowStyle
parseArrowStyle :: String -> XParse ArrowStyle

-- | <tt>backward-forward</tt> <i>(simple)</i>
--   
--   The backward-forward type is used to specify repeat directions. The
--   start of the repeat has a forward direction while the end of the
--   repeat has a backward direction.
data BackwardForward

-- | <i>backward</i>
BackwardForwardBackward :: BackwardForward

-- | <i>forward</i>
BackwardForwardForward :: BackwardForward
parseBackwardForward :: String -> XParse BackwardForward

-- | <tt>bar-style</tt> <i>(simple)</i>
--   
--   The bar-style type represents barline style information. Choices are
--   regular, dotted, dashed, heavy, light-light, light-heavy, heavy-light,
--   heavy-heavy, tick (a short stroke through the top line), short (a
--   partial barline between the 2nd and 4th lines), and none.
data BarStyle

-- | <i>regular</i>
BarStyleRegular :: BarStyle

-- | <i>dotted</i>
BarStyleDotted :: BarStyle

-- | <i>dashed</i>
BarStyleDashed :: BarStyle

-- | <i>heavy</i>
BarStyleHeavy :: BarStyle

-- | <i>light-light</i>
BarStyleLightLight :: BarStyle

-- | <i>light-heavy</i>
BarStyleLightHeavy :: BarStyle

-- | <i>heavy-light</i>
BarStyleHeavyLight :: BarStyle

-- | <i>heavy-heavy</i>
BarStyleHeavyHeavy :: BarStyle

-- | <i>tick</i>
BarStyleTick :: BarStyle

-- | <i>short</i>
BarStyleShort :: BarStyle

-- | <i>none</i>
BarStyleNone :: BarStyle
parseBarStyle :: String -> XParse BarStyle

-- | <tt>beam-level</tt> <i>(simple)</i>
--   
--   The MusicXML format supports six levels of beaming, up to 1024th
--   notes. Unlike the number-level type, the beam-level type identifies
--   concurrent beams in a beam group. It does not distinguish overlapping
--   beams such as grace notes within regular notes, or beams used in
--   different voices.
newtype BeamLevel
BeamLevel :: PositiveInteger -> BeamLevel
[beamLevel] :: BeamLevel -> PositiveInteger
parseBeamLevel :: String -> XParse BeamLevel

-- | <tt>beam-value</tt> <i>(simple)</i>
--   
--   The beam-value type represents the type of beam associated with each
--   of 8 beam levels (up to 1024th notes) available for each note.
data BeamValue

-- | <i>begin</i>
BeamValueBegin :: BeamValue

-- | <i>continue</i>
BeamValueContinue :: BeamValue

-- | <i>end</i>
BeamValueEnd :: BeamValue

-- | <i>forward hook</i>
BeamValueForwardHook :: BeamValue

-- | <i>backward hook</i>
BeamValueBackwardHook :: BeamValue
parseBeamValue :: String -> XParse BeamValue

-- | <tt>beater-value</tt> <i>(simple)</i>
--   
--   The beater-value type represents pictograms for beaters, mallets, and
--   sticks that do not have different materials represented in the
--   pictogram. The finger and hammer values are in addition to Stone's
--   list.
data BeaterValue

-- | <i>bow</i>
BeaterValueBow :: BeaterValue

-- | <i>chime hammer</i>
BeaterValueChimeHammer :: BeaterValue

-- | <i>coin</i>
BeaterValueCoin :: BeaterValue

-- | <i>drum stick</i>
BeaterValueDrumStick :: BeaterValue

-- | <i>finger</i>
BeaterValueFinger :: BeaterValue

-- | <i>fingernail</i>
BeaterValueFingernail :: BeaterValue

-- | <i>fist</i>
BeaterValueFist :: BeaterValue

-- | <i>guiro scraper</i>
BeaterValueGuiroScraper :: BeaterValue

-- | <i>hammer</i>
BeaterValueHammer :: BeaterValue

-- | <i>hand</i>
BeaterValueHand :: BeaterValue

-- | <i>jazz stick</i>
BeaterValueJazzStick :: BeaterValue

-- | <i>knitting needle</i>
BeaterValueKnittingNeedle :: BeaterValue

-- | <i>metal hammer</i>
BeaterValueMetalHammer :: BeaterValue

-- | <i>slide brush on gong</i>
BeaterValueSlideBrushOnGong :: BeaterValue

-- | <i>snare stick</i>
BeaterValueSnareStick :: BeaterValue

-- | <i>spoon mallet</i>
BeaterValueSpoonMallet :: BeaterValue

-- | <i>superball</i>
BeaterValueSuperball :: BeaterValue

-- | <i>triangle beater</i>
BeaterValueTriangleBeater :: BeaterValue

-- | <i>triangle beater plain</i>
BeaterValueTriangleBeaterPlain :: BeaterValue

-- | <i>wire brush</i>
BeaterValueWireBrush :: BeaterValue
parseBeaterValue :: String -> XParse BeaterValue

-- | <tt>breath-mark-value</tt> <i>(simple)</i>
--   
--   The breath-mark-value type represents the symbol used for a breath
--   mark.
data BreathMarkValue

-- | //
BreathMarkValue :: BreathMarkValue

-- | <i>comma</i>
BreathMarkValueComma :: BreathMarkValue

-- | <i>tick</i>
BreathMarkValueTick :: BreathMarkValue

-- | <i>upbow</i>
BreathMarkValueUpbow :: BreathMarkValue

-- | <i>salzedo</i>
BreathMarkValueSalzedo :: BreathMarkValue
parseBreathMarkValue :: String -> XParse BreathMarkValue

-- | <tt>caesura-value</tt> <i>(simple)</i>
--   
--   The caesura-value type represents the shape of the caesura sign.
data CaesuraValue

-- | <i>normal</i>
CaesuraValueNormal :: CaesuraValue

-- | <i>thick</i>
CaesuraValueThick :: CaesuraValue

-- | <i>short</i>
CaesuraValueShort :: CaesuraValue

-- | <i>curved</i>
CaesuraValueCurved :: CaesuraValue

-- | <i>single</i>
CaesuraValueSingle :: CaesuraValue

-- | //
CaesuraValue :: CaesuraValue
parseCaesuraValue :: String -> XParse CaesuraValue

-- | <tt>cancel-location</tt> <i>(simple)</i>
--   
--   The cancel-location type is used to indicate where a key signature
--   cancellation appears relative to a new key signature: to the left, to
--   the right, or before the barline and to the left. It is left by
--   default. For mid-measure key elements, a cancel-location of
--   before-barline should be treated like a cancel-location of left.
data CancelLocation

-- | <i>left</i>
CancelLocationLeft :: CancelLocation

-- | <i>right</i>
CancelLocationRight :: CancelLocation

-- | <i>before-barline</i>
CancelLocationBeforeBarline :: CancelLocation
parseCancelLocation :: String -> XParse CancelLocation

-- | <tt>circular-arrow</tt> <i>(simple)</i>
--   
--   The circular-arrow type represents the direction in which a circular
--   arrow points, using Unicode arrow terminology.
data CircularArrow

-- | <i>clockwise</i>
CircularArrowClockwise :: CircularArrow

-- | <i>anticlockwise</i>
CircularArrowAnticlockwise :: CircularArrow
parseCircularArrow :: String -> XParse CircularArrow

-- | <tt>clef-sign</tt> <i>(simple)</i>
--   
--   The clef-sign element represents the different clef symbols. The
--   jianpu sign indicates that the music that follows should be in jianpu
--   numbered notation, just as the TAB sign indicates that the music that
--   follows should be in tablature notation. Unlike TAB, a jianpu sign
--   does not correspond to a visual clef notation.
data ClefSign

-- | <i>G</i>
ClefSignG :: ClefSign

-- | <i>F</i>
ClefSignF :: ClefSign

-- | <i>C</i>
ClefSignC :: ClefSign

-- | <i>percussion</i>
ClefSignPercussion :: ClefSign

-- | <i>TAB</i>
ClefSignTAB :: ClefSign

-- | <i>jianpu</i>
ClefSignJianpu :: ClefSign

-- | <i>none</i>
ClefSignNone :: ClefSign
parseClefSign :: String -> XParse ClefSign

-- | <tt>color</tt> <i>(simple)</i>
--   
--   The color type indicates the color of an element. Color may be
--   represented as hexadecimal RGB triples, as in HTML, or as hexadecimal
--   ARGB tuples, with the A indicating alpha of transparency. An alpha
--   value of 00 is totally transparent; FF is totally opaque. If RGB is
--   used, the A value is assumed to be FF.
--   
--   For instance, the RGB value "#800080" represents purple. An ARGB value
--   of "#40800080" would be a transparent purple.
--   
--   As in SVG 1.1, colors are defined in terms of the sRGB color space
--   (IEC 61966).
newtype Color
Color :: Token -> Color
[color] :: Color -> Token
parseColor :: String -> XParse Color

-- | <tt>comma-separated-text</tt> <i>(simple)</i>
--   
--   The comma-separated-text type is used to specify a comma-separated
--   list of text elements, as is used by the font-family attribute.
newtype CommaSeparatedText
CommaSeparatedText :: Token -> CommaSeparatedText
[commaSeparatedText] :: CommaSeparatedText -> Token
parseCommaSeparatedText :: String -> XParse CommaSeparatedText

-- | <tt>css-font-size</tt> <i>(simple)</i>
--   
--   The css-font-size type includes the CSS font sizes used as an
--   alternative to a numeric point size.
data CssFontSize

-- | <i>xx-small</i>
CssFontSizeXxSmall :: CssFontSize

-- | <i>x-small</i>
CssFontSizeXSmall :: CssFontSize

-- | <i>small</i>
CssFontSizeSmall :: CssFontSize

-- | <i>medium</i>
CssFontSizeMedium :: CssFontSize

-- | <i>large</i>
CssFontSizeLarge :: CssFontSize

-- | <i>x-large</i>
CssFontSizeXLarge :: CssFontSize

-- | <i>xx-large</i>
CssFontSizeXxLarge :: CssFontSize
parseCssFontSize :: String -> XParse CssFontSize

-- | <tt>degree-symbol-value</tt> <i>(simple)</i>
--   
--   The degree-symbol-value type indicates indicates that a symbol should
--   be used in specifying the degree.
data DegreeSymbolValue

-- | <i>major</i>
DegreeSymbolValueMajor :: DegreeSymbolValue

-- | <i>minor</i>
DegreeSymbolValueMinor :: DegreeSymbolValue

-- | <i>augmented</i>
DegreeSymbolValueAugmented :: DegreeSymbolValue

-- | <i>diminished</i>
DegreeSymbolValueDiminished :: DegreeSymbolValue

-- | <i>half-diminished</i>
DegreeSymbolValueHalfDiminished :: DegreeSymbolValue
parseDegreeSymbolValue :: String -> XParse DegreeSymbolValue

-- | <tt>degree-type-value</tt> <i>(simple)</i>
--   
--   The degree-type-value type indicates whether the current degree
--   element is an addition, alteration, or subtraction to the kind of the
--   current chord in the harmony element.
data DegreeTypeValue

-- | <i>add</i>
DegreeTypeValueAdd :: DegreeTypeValue

-- | <i>alter</i>
DegreeTypeValueAlter :: DegreeTypeValue

-- | <i>subtract</i>
DegreeTypeValueSubtract :: DegreeTypeValue
parseDegreeTypeValue :: String -> XParse DegreeTypeValue

-- | <tt>distance-type</tt> <i>(simple)</i>
--   
--   The distance-type defines what type of distance is being defined in a
--   distance element. Values include beam and hyphen. This is left as a
--   string so that other application-specific types can be defined, but it
--   is made a separate type so that it can be redefined more strictly.
newtype DistanceType
DistanceType :: Token -> DistanceType
[distanceType] :: DistanceType -> Token
parseDistanceType :: String -> XParse DistanceType

-- | <tt>divisions</tt> <i>(simple)</i>
--   
--   The divisions type is used to express values in terms of the musical
--   divisions defined by the divisions element. It is preferred that these
--   be integer values both for MIDI interoperability and to avoid roundoff
--   errors.
newtype Divisions
Divisions :: Decimal -> Divisions
[divisions] :: Divisions -> Decimal
parseDivisions :: String -> XParse Divisions

-- | <tt>effect</tt> <i>(simple)</i>
--   
--   The effect type represents pictograms for sound effect percussion
--   instruments. The cannon, lotus flute, and megaphone values are in
--   addition to Stone's list.
data Effect

-- | <i>anvil</i>
EffectAnvil :: Effect

-- | <i>auto horn</i>
EffectAutoHorn :: Effect

-- | <i>bird whistle</i>
EffectBirdWhistle :: Effect

-- | <i>cannon</i>
EffectCannon :: Effect

-- | <i>duck call</i>
EffectDuckCall :: Effect

-- | <i>gun shot</i>
EffectGunShot :: Effect

-- | <i>klaxon horn</i>
EffectKlaxonHorn :: Effect

-- | <i>lions roar</i>
EffectLionsRoar :: Effect

-- | <i>lotus flute</i>
EffectLotusFlute :: Effect

-- | <i>megaphone</i>
EffectMegaphone :: Effect

-- | <i>police whistle</i>
EffectPoliceWhistle :: Effect

-- | <i>siren</i>
EffectSiren :: Effect

-- | <i>slide whistle</i>
EffectSlideWhistle :: Effect

-- | <i>thunder sheet</i>
EffectThunderSheet :: Effect

-- | <i>wind machine</i>
EffectWindMachine :: Effect

-- | <i>wind whistle</i>
EffectWindWhistle :: Effect
parseEffect :: String -> XParse Effect

-- | <tt>enclosure-shape</tt> <i>(simple)</i>
--   
--   The enclosure-shape type describes the shape and presence / absence of
--   an enclosure around text or symbols. A bracket enclosure is similar to
--   a rectangle with the bottom line missing, as is common in jazz
--   notation.
data EnclosureShape

-- | <i>rectangle</i>
EnclosureShapeRectangle :: EnclosureShape

-- | <i>square</i>
EnclosureShapeSquare :: EnclosureShape

-- | <i>oval</i>
EnclosureShapeOval :: EnclosureShape

-- | <i>circle</i>
EnclosureShapeCircle :: EnclosureShape

-- | <i>bracket</i>
EnclosureShapeBracket :: EnclosureShape

-- | <i>triangle</i>
EnclosureShapeTriangle :: EnclosureShape

-- | <i>diamond</i>
EnclosureShapeDiamond :: EnclosureShape

-- | <i>pentagon</i>
EnclosureShapePentagon :: EnclosureShape

-- | <i>hexagon</i>
EnclosureShapeHexagon :: EnclosureShape

-- | <i>heptagon</i>
EnclosureShapeHeptagon :: EnclosureShape

-- | <i>octagon</i>
EnclosureShapeOctagon :: EnclosureShape

-- | <i>nonagon</i>
EnclosureShapeNonagon :: EnclosureShape

-- | <i>decagon</i>
EnclosureShapeDecagon :: EnclosureShape

-- | <i>none</i>
EnclosureShapeNone :: EnclosureShape
parseEnclosureShape :: String -> XParse EnclosureShape

-- | <tt>ending-number</tt> <i>(simple)</i>
--   
--   The ending-number type is used to specify either a comma-separated
--   list of positive integers without leading zeros, or a string of zero
--   or more spaces. It is used for the number attribute of the ending
--   element. The zero or more spaces version is used when software knows
--   that an ending is present, but cannot determine the type of the
--   ending.
newtype EndingNumber
EndingNumber :: Token -> EndingNumber
[endingNumber] :: EndingNumber -> Token
parseEndingNumber :: String -> XParse EndingNumber

-- | <tt>fan</tt> <i>(simple)</i>
--   
--   The fan type represents the type of beam fanning present on a note,
--   used to represent accelerandos and ritardandos.
data Fan

-- | <i>accel</i>
FanAccel :: Fan

-- | <i>rit</i>
FanRit :: Fan

-- | <i>none</i>
FanNone :: Fan
parseFan :: String -> XParse Fan

-- | <tt>fermata-shape</tt> <i>(simple)</i>
--   
--   The fermata-shape type represents the shape of the fermata sign. The
--   empty value is equivalent to the normal value.
data FermataShape

-- | <i>normal</i>
FermataShapeNormal :: FermataShape

-- | <i>angled</i>
FermataShapeAngled :: FermataShape

-- | <i>square</i>
FermataShapeSquare :: FermataShape

-- | <i>double-angled</i>
FermataShapeDoubleAngled :: FermataShape

-- | <i>double-square</i>
FermataShapeDoubleSquare :: FermataShape

-- | <i>double-dot</i>
FermataShapeDoubleDot :: FermataShape

-- | <i>half-curve</i>
FermataShapeHalfCurve :: FermataShape

-- | <i>curlew</i>
FermataShapeCurlew :: FermataShape

-- | //
FermataShape :: FermataShape
parseFermataShape :: String -> XParse FermataShape

-- | <tt>fifths</tt> <i>(simple)</i>
--   
--   The fifths type represents the number of flats or sharps in a
--   traditional key signature. Negative numbers are used for flats and
--   positive numbers for sharps, reflecting the key's placement within the
--   circle of fifths (hence the type name).
newtype Fifths
Fifths :: Int -> Fifths
[fifths] :: Fifths -> Int
parseFifths :: String -> XParse Fifths

-- | <tt>font-size</tt> <i>(simple)</i>
--   
--   The font-size can be one of the CSS font sizes or a numeric point
--   size.
data FontSize
FontSizeDecimal :: Decimal -> FontSize
[fontSize1] :: FontSize -> Decimal
FontSizeCssFontSize :: CssFontSize -> FontSize
[fontSize2] :: FontSize -> CssFontSize
parseFontSize :: String -> XParse FontSize

-- | <tt>font-style</tt> <i>(simple)</i>
--   
--   The font-style type represents a simplified version of the CSS
--   font-style property.
data FontStyle

-- | <i>normal</i>
FontStyleNormal :: FontStyle

-- | <i>italic</i>
FontStyleItalic :: FontStyle
parseFontStyle :: String -> XParse FontStyle

-- | <tt>font-weight</tt> <i>(simple)</i>
--   
--   The font-weight type represents a simplified version of the CSS
--   font-weight property.
data FontWeight

-- | <i>normal</i>
FontWeightNormal :: FontWeight

-- | <i>bold</i>
FontWeightBold :: FontWeight
parseFontWeight :: String -> XParse FontWeight

-- | <tt>glass-value</tt> <i>(simple)</i>
--   
--   The glass-value type represents pictograms for glass percussion
--   instruments.
data GlassValue

-- | <i>glass harmonica</i>
GlassValueGlassHarmonica :: GlassValue

-- | <i>glass harp</i>
GlassValueGlassHarp :: GlassValue

-- | <i>wind chimes</i>
GlassValueWindChimes :: GlassValue
parseGlassValue :: String -> XParse GlassValue

-- | <tt>glyph-type</tt> <i>(simple)</i>
--   
--   The glyph-type defines what type of glyph is being defined in a glyph
--   element. Values include quarter-rest, g-clef-ottava-bassa, c-clef,
--   f-clef, percussion-clef, octave-shift-up-8, octave-shift-down-8,
--   octave-shift-continue-8, octave-shift-down-15, octave-shift-up-15,
--   octave-shift-continue-15, octave-shift-down-22, octave-shift-up-22,
--   and octave-shift-continue-22. This is left as a string so that other
--   application-specific types can be defined, but it is made a separate
--   type so that it can be redefined more strictly.
--   
--   A quarter-rest type specifies the glyph to use when a note has a rest
--   element and a type value of quarter. The c-clef, f-clef, and
--   percussion-clef types specify the glyph to use when a clef sign
--   element value is C, F, or percussion respectively. The
--   g-clef-ottava-bassa type specifies the glyph to use when a clef sign
--   element value is G and the clef-octave-change element value is -1. The
--   octave-shift types specify the glyph to use when an octave-shift type
--   attribute value is up, down, or continue and the octave-shift size
--   attribute value is 8, 15, or 22.
newtype GlyphType
GlyphType :: Token -> GlyphType
[glyphType] :: GlyphType -> Token
parseGlyphType :: String -> XParse GlyphType

-- | <tt>group-barline-value</tt> <i>(simple)</i>
--   
--   The group-barline-value type indicates if the group should have common
--   barlines.
data GroupBarlineValue

-- | <i>yes</i>
GroupBarlineValueYes :: GroupBarlineValue

-- | <i>no</i>
GroupBarlineValueNo :: GroupBarlineValue

-- | <i>Mensurstrich</i>
GroupBarlineValueMensurstrich :: GroupBarlineValue
parseGroupBarlineValue :: String -> XParse GroupBarlineValue

-- | <tt>group-symbol-value</tt> <i>(simple)</i>
--   
--   The group-symbol-value type indicates how the symbol for a group is
--   indicated in the score. The default value is none.
data GroupSymbolValue

-- | <i>none</i>
GroupSymbolValueNone :: GroupSymbolValue

-- | <i>brace</i>
GroupSymbolValueBrace :: GroupSymbolValue

-- | <i>line</i>
GroupSymbolValueLine :: GroupSymbolValue

-- | <i>bracket</i>
GroupSymbolValueBracket :: GroupSymbolValue

-- | <i>square</i>
GroupSymbolValueSquare :: GroupSymbolValue
parseGroupSymbolValue :: String -> XParse GroupSymbolValue

-- | <tt>handbell-value</tt> <i>(simple)</i>
--   
--   The handbell-value type represents the type of handbell technique
--   being notated.
data HandbellValue

-- | <i>belltree</i>
HandbellValueBelltree :: HandbellValue

-- | <i>damp</i>
HandbellValueDamp :: HandbellValue

-- | <i>echo</i>
HandbellValueEcho :: HandbellValue

-- | <i>gyro</i>
HandbellValueGyro :: HandbellValue

-- | <i>hand martellato</i>
HandbellValueHandMartellato :: HandbellValue

-- | <i>mallet lift</i>
HandbellValueMalletLift :: HandbellValue

-- | <i>mallet table</i>
HandbellValueMalletTable :: HandbellValue

-- | <i>martellato</i>
HandbellValueMartellato :: HandbellValue

-- | <i>martellato lift</i>
HandbellValueMartellatoLift :: HandbellValue

-- | <i>muted martellato</i>
HandbellValueMutedMartellato :: HandbellValue

-- | <i>pluck lift</i>
HandbellValuePluckLift :: HandbellValue

-- | <i>swing</i>
HandbellValueSwing :: HandbellValue
parseHandbellValue :: String -> XParse HandbellValue

-- | <tt>harmon-closed-location</tt> <i>(simple)</i>
--   
--   The harmon-closed-location type indicates which portion of the symbol
--   is filled in when the corresponding harmon-closed-value is half.
data HarmonClosedLocation

-- | <i>right</i>
HarmonClosedLocationRight :: HarmonClosedLocation

-- | <i>bottom</i>
HarmonClosedLocationBottom :: HarmonClosedLocation

-- | <i>left</i>
HarmonClosedLocationLeft :: HarmonClosedLocation

-- | <i>top</i>
HarmonClosedLocationTop :: HarmonClosedLocation
parseHarmonClosedLocation :: String -> XParse HarmonClosedLocation

-- | <tt>harmon-closed-value</tt> <i>(simple)</i>
--   
--   The harmon-closed-value type represents whether the harmon mute is
--   closed, open, or half-open.
data HarmonClosedValue

-- | <i>yes</i>
HarmonClosedValueYes :: HarmonClosedValue

-- | <i>no</i>
HarmonClosedValueNo :: HarmonClosedValue

-- | <i>half</i>
HarmonClosedValueHalf :: HarmonClosedValue
parseHarmonClosedValue :: String -> XParse HarmonClosedValue

-- | <tt>harmony-type</tt> <i>(simple)</i>
--   
--   The harmony-type type differentiates different types of harmonies when
--   alternate harmonies are possible. Explicit harmonies have all note
--   present in the music; implied have some notes missing but implied;
--   alternate represents alternate analyses.
data HarmonyType

-- | <i>explicit</i>
HarmonyTypeExplicit :: HarmonyType

-- | <i>implied</i>
HarmonyTypeImplied :: HarmonyType

-- | <i>alternate</i>
HarmonyTypeAlternate :: HarmonyType
parseHarmonyType :: String -> XParse HarmonyType

-- | <tt>hole-closed-location</tt> <i>(simple)</i>
--   
--   The hole-closed-location type indicates which portion of the hole is
--   filled in when the corresponding hole-closed-value is half.
data HoleClosedLocation

-- | <i>right</i>
HoleClosedLocationRight :: HoleClosedLocation

-- | <i>bottom</i>
HoleClosedLocationBottom :: HoleClosedLocation

-- | <i>left</i>
HoleClosedLocationLeft :: HoleClosedLocation

-- | <i>top</i>
HoleClosedLocationTop :: HoleClosedLocation
parseHoleClosedLocation :: String -> XParse HoleClosedLocation

-- | <tt>hole-closed-value</tt> <i>(simple)</i>
--   
--   The hole-closed-value type represents whether the hole is closed,
--   open, or half-open.
data HoleClosedValue

-- | <i>yes</i>
HoleClosedValueYes :: HoleClosedValue

-- | <i>no</i>
HoleClosedValueNo :: HoleClosedValue

-- | <i>half</i>
HoleClosedValueHalf :: HoleClosedValue
parseHoleClosedValue :: String -> XParse HoleClosedValue

-- | <tt>kind-value</tt> <i>(simple)</i>
--   
--   A kind-value indicates the type of chord. Degree elements can then
--   add, subtract, or alter from these starting points. Values include:
--   
--   <pre>
--   Triads:
--   	major (major third, perfect fifth)
--   	minor (minor third, perfect fifth)
--   	augmented (major third, augmented fifth)
--   	diminished (minor third, diminished fifth)
--   Sevenths:
--   	dominant (major triad, minor seventh)
--   	major-seventh (major triad, major seventh)
--   	minor-seventh (minor triad, minor seventh)
--   	diminished-seventh (diminished triad, diminished seventh)
--   	augmented-seventh (augmented triad, minor seventh)
--   	half-diminished (diminished triad, minor seventh)
--   	major-minor (minor triad, major seventh)
--   Sixths:
--   	major-sixth (major triad, added sixth)
--   	minor-sixth (minor triad, added sixth)
--   Ninths:
--   	dominant-ninth (dominant-seventh, major ninth)
--   	major-ninth (major-seventh, major ninth)
--   	minor-ninth (minor-seventh, major ninth)
--   11ths (usually as the basis for alteration):
--   	dominant-11th (dominant-ninth, perfect 11th)
--   	major-11th (major-ninth, perfect 11th)
--   	minor-11th (minor-ninth, perfect 11th)
--   13ths (usually as the basis for alteration):
--   	dominant-13th (dominant-11th, major 13th)
--   	major-13th (major-11th, major 13th)
--   	minor-13th (minor-11th, major 13th)
--   Suspended:
--   	suspended-second (major second, perfect fifth)
--   	suspended-fourth (perfect fourth, perfect fifth)
--   Functional sixths:
--   	Neapolitan
--   	Italian
--   	French
--   	German
--   Other:
--   	pedal (pedal-point bass)
--   	power (perfect fifth)
--   	Tristan
--   
--   The "other" kind is used when the harmony is entirely composed of add elements. The "none" kind is used to explicitly encode absence of chords or functional harmony.
--   </pre>
data KindValue

-- | <i>major</i>
KindValueMajor :: KindValue

-- | <i>minor</i>
KindValueMinor :: KindValue

-- | <i>augmented</i>
KindValueAugmented :: KindValue

-- | <i>diminished</i>
KindValueDiminished :: KindValue

-- | <i>dominant</i>
KindValueDominant :: KindValue

-- | <i>major-seventh</i>
KindValueMajorSeventh :: KindValue

-- | <i>minor-seventh</i>
KindValueMinorSeventh :: KindValue

-- | <i>diminished-seventh</i>
KindValueDiminishedSeventh :: KindValue

-- | <i>augmented-seventh</i>
KindValueAugmentedSeventh :: KindValue

-- | <i>half-diminished</i>
KindValueHalfDiminished :: KindValue

-- | <i>major-minor</i>
KindValueMajorMinor :: KindValue

-- | <i>major-sixth</i>
KindValueMajorSixth :: KindValue

-- | <i>minor-sixth</i>
KindValueMinorSixth :: KindValue

-- | <i>dominant-ninth</i>
KindValueDominantNinth :: KindValue

-- | <i>major-ninth</i>
KindValueMajorNinth :: KindValue

-- | <i>minor-ninth</i>
KindValueMinorNinth :: KindValue

-- | <i>dominant-11th</i>
KindValueDominant11th :: KindValue

-- | <i>major-11th</i>
KindValueMajor11th :: KindValue

-- | <i>minor-11th</i>
KindValueMinor11th :: KindValue

-- | <i>dominant-13th</i>
KindValueDominant13th :: KindValue

-- | <i>major-13th</i>
KindValueMajor13th :: KindValue

-- | <i>minor-13th</i>
KindValueMinor13th :: KindValue

-- | <i>suspended-second</i>
KindValueSuspendedSecond :: KindValue

-- | <i>suspended-fourth</i>
KindValueSuspendedFourth :: KindValue

-- | <i>Neapolitan</i>
KindValueNeapolitan :: KindValue

-- | <i>Italian</i>
KindValueItalian :: KindValue

-- | <i>French</i>
KindValueFrench :: KindValue

-- | <i>German</i>
KindValueGerman :: KindValue

-- | <i>pedal</i>
KindValuePedal :: KindValue

-- | <i>power</i>
KindValuePower :: KindValue

-- | <i>Tristan</i>
KindValueTristan :: KindValue

-- | <i>other</i>
KindValueOther :: KindValue

-- | <i>none</i>
KindValueNone :: KindValue
parseKindValue :: String -> XParse KindValue

-- | <tt>xml:lang</tt> <i>(simple)</i>
data Lang
LangLanguage :: Language -> Lang
[lang1] :: Lang -> Language
LangLang :: SumLang -> Lang
[lang2] :: Lang -> SumLang
parseLang :: String -> XParse Lang

-- | <tt>xs:language</tt> <i>(simple)</i>
newtype Language
Language :: Token -> Language
[language] :: Language -> Token
parseLanguage :: String -> XParse Language

-- | <tt>left-center-right</tt> <i>(simple)</i>
--   
--   The left-center-right type is used to define horizontal alignment and
--   text justification.
data LeftCenterRight

-- | <i>left</i>
LeftCenterRightLeft :: LeftCenterRight

-- | <i>center</i>
LeftCenterRightCenter :: LeftCenterRight

-- | <i>right</i>
LeftCenterRightRight :: LeftCenterRight
parseLeftCenterRight :: String -> XParse LeftCenterRight

-- | <tt>left-right</tt> <i>(simple)</i>
--   
--   The left-right type is used to indicate whether one element appears to
--   the left or the right of another element.
data LeftRight

-- | <i>left</i>
LeftRightLeft :: LeftRight

-- | <i>right</i>
LeftRightRight :: LeftRight
parseLeftRight :: String -> XParse LeftRight

-- | <tt>line-end</tt> <i>(simple)</i>
--   
--   The line-end type specifies if there is a jog up or down (or both), an
--   arrow, or nothing at the start or end of a bracket.
data LineEnd

-- | <i>up</i>
LineEndUp :: LineEnd

-- | <i>down</i>
LineEndDown :: LineEnd

-- | <i>both</i>
LineEndBoth :: LineEnd

-- | <i>arrow</i>
LineEndArrow :: LineEnd

-- | <i>none</i>
LineEndNone :: LineEnd
parseLineEnd :: String -> XParse LineEnd

-- | <tt>line-length</tt> <i>(simple)</i>
--   
--   The line-length type distinguishes between different line lengths for
--   doit, falloff, plop, and scoop articulations.
data LineLength

-- | <i>short</i>
LineLengthShort :: LineLength

-- | <i>medium</i>
LineLengthMedium :: LineLength

-- | <i>long</i>
LineLengthLong :: LineLength
parseLineLength :: String -> XParse LineLength

-- | <tt>line-shape</tt> <i>(simple)</i>
--   
--   The line-shape type distinguishes between straight and curved lines.
data LineShape

-- | <i>straight</i>
LineShapeStraight :: LineShape

-- | <i>curved</i>
LineShapeCurved :: LineShape
parseLineShape :: String -> XParse LineShape

-- | <tt>line-type</tt> <i>(simple)</i>
--   
--   The line-type type distinguishes between solid, dashed, dotted, and
--   wavy lines.
data LineType

-- | <i>solid</i>
LineTypeSolid :: LineType

-- | <i>dashed</i>
LineTypeDashed :: LineType

-- | <i>dotted</i>
LineTypeDotted :: LineType

-- | <i>wavy</i>
LineTypeWavy :: LineType
parseLineType :: String -> XParse LineType

-- | <tt>line-width-type</tt> <i>(simple)</i>
--   
--   The line-width-type defines what type of line is being defined in a
--   line-width element. Values include beam, bracket, dashes, enclosure,
--   ending, extend, heavy barline, leger, light barline, octave shift,
--   pedal, slur middle, slur tip, staff, stem, tie middle, tie tip, tuplet
--   bracket, and wedge. This is left as a string so that other
--   application-specific types can be defined, but it is made a separate
--   type so that it can be redefined more strictly.
newtype LineWidthType
LineWidthType :: Token -> LineWidthType
[lineWidthType] :: LineWidthType -> Token
parseLineWidthType :: String -> XParse LineWidthType

-- | <tt>margin-type</tt> <i>(simple)</i>
--   
--   The margin-type type specifies whether margins apply to even page, odd
--   pages, or both.
data MarginType

-- | <i>odd</i>
MarginTypeOdd :: MarginType

-- | <i>even</i>
MarginTypeEven :: MarginType

-- | <i>both</i>
MarginTypeBoth :: MarginType
parseMarginType :: String -> XParse MarginType

-- | <tt>measure-numbering-value</tt> <i>(simple)</i>
--   
--   The measure-numbering-value type describes how measure numbers are
--   displayed on this part: no numbers, numbers every measure, or numbers
--   every system.
data MeasureNumberingValue

-- | <i>none</i>
MeasureNumberingValueNone :: MeasureNumberingValue

-- | <i>measure</i>
MeasureNumberingValueMeasure :: MeasureNumberingValue

-- | <i>system</i>
MeasureNumberingValueSystem :: MeasureNumberingValue
parseMeasureNumberingValue :: String -> XParse MeasureNumberingValue

-- | <tt>measure-text</tt> <i>(simple)</i>
--   
--   The measure-text type is used for the text attribute of measure
--   elements. It has at least one character. The implicit attribute of the
--   measure element should be set to "yes" rather than setting the text
--   attribute to an empty string.
newtype MeasureText
MeasureText :: Token -> MeasureText
[measureText] :: MeasureText -> Token
parseMeasureText :: String -> XParse MeasureText

-- | <tt>membrane</tt> <i>(simple)</i>
--   
--   The membrane type represents pictograms for membrane percussion
--   instruments.
data Membrane

-- | <i>bass drum</i>
MembraneBassDrum :: Membrane

-- | <i>bass drum on side</i>
MembraneBassDrumOnSide :: Membrane

-- | <i>bongos</i>
MembraneBongos :: Membrane

-- | <i>Chinese tomtom</i>
MembraneChineseTomtom :: Membrane

-- | <i>conga drum</i>
MembraneCongaDrum :: Membrane

-- | <i>cuica</i>
MembraneCuica :: Membrane

-- | <i>goblet drum</i>
MembraneGobletDrum :: Membrane

-- | <i>Indo-American tomtom</i>
MembraneIndoAmericanTomtom :: Membrane

-- | <i>Japanese tomtom</i>
MembraneJapaneseTomtom :: Membrane

-- | <i>military drum</i>
MembraneMilitaryDrum :: Membrane

-- | <i>snare drum</i>
MembraneSnareDrum :: Membrane

-- | <i>snare drum snares off</i>
MembraneSnareDrumSnaresOff :: Membrane

-- | <i>tabla</i>
MembraneTabla :: Membrane

-- | <i>tambourine</i>
MembraneTambourine :: Membrane

-- | <i>tenor drum</i>
MembraneTenorDrum :: Membrane

-- | <i>timbales</i>
MembraneTimbales :: Membrane

-- | <i>tomtom</i>
MembraneTomtom :: Membrane
parseMembrane :: String -> XParse Membrane

-- | <tt>metal</tt> <i>(simple)</i>
--   
--   The metal type represents pictograms for metal percussion instruments.
--   The hi-hat value refers to a pictogram like Stone's high-hat cymbals
--   but without the long vertical line at the bottom.
data Metal

-- | <i>agogo</i>
MetalAgogo :: Metal

-- | <i>almglocken</i>
MetalAlmglocken :: Metal

-- | <i>bell</i>
MetalBell :: Metal

-- | <i>bell plate</i>
MetalBellPlate :: Metal

-- | <i>bell tree</i>
MetalBellTree :: Metal

-- | <i>brake drum</i>
MetalBrakeDrum :: Metal

-- | <i>cencerro</i>
MetalCencerro :: Metal

-- | <i>chain rattle</i>
MetalChainRattle :: Metal

-- | <i>Chinese cymbal</i>
MetalChineseCymbal :: Metal

-- | <i>cowbell</i>
MetalCowbell :: Metal

-- | <i>crash cymbals</i>
MetalCrashCymbals :: Metal

-- | <i>crotale</i>
MetalCrotale :: Metal

-- | <i>cymbal tongs</i>
MetalCymbalTongs :: Metal

-- | <i>domed gong</i>
MetalDomedGong :: Metal

-- | <i>finger cymbals</i>
MetalFingerCymbals :: Metal

-- | <i>flexatone</i>
MetalFlexatone :: Metal

-- | <i>gong</i>
MetalGong :: Metal

-- | <i>hi-hat</i>
MetalHiHat :: Metal

-- | <i>high-hat cymbals</i>
MetalHighHatCymbals :: Metal

-- | <i>handbell</i>
MetalHandbell :: Metal

-- | <i>jaw harp</i>
MetalJawHarp :: Metal

-- | <i>jingle bells</i>
MetalJingleBells :: Metal

-- | <i>musical saw</i>
MetalMusicalSaw :: Metal

-- | <i>shell bells</i>
MetalShellBells :: Metal

-- | <i>sistrum</i>
MetalSistrum :: Metal

-- | <i>sizzle cymbal</i>
MetalSizzleCymbal :: Metal

-- | <i>sleigh bells</i>
MetalSleighBells :: Metal

-- | <i>suspended cymbal</i>
MetalSuspendedCymbal :: Metal

-- | <i>tam tam</i>
MetalTamTam :: Metal

-- | <i>tam tam with beater</i>
MetalTamTamWithBeater :: Metal

-- | <i>triangle</i>
MetalTriangle :: Metal

-- | <i>Vietnamese hat</i>
MetalVietnameseHat :: Metal
parseMetal :: String -> XParse Metal

-- | <tt>midi-128</tt> <i>(simple)</i>
--   
--   The midi-16 type is used to express MIDI 1.0 values that range from 1
--   to 128.
newtype Midi128
Midi128 :: PositiveInteger -> Midi128
[midi128] :: Midi128 -> PositiveInteger
parseMidi128 :: String -> XParse Midi128

-- | <tt>midi-16</tt> <i>(simple)</i>
--   
--   The midi-16 type is used to express MIDI 1.0 values that range from 1
--   to 16.
newtype Midi16
Midi16 :: PositiveInteger -> Midi16
[midi16] :: Midi16 -> PositiveInteger
parseMidi16 :: String -> XParse Midi16

-- | <tt>midi-16384</tt> <i>(simple)</i>
--   
--   The midi-16 type is used to express MIDI 1.0 values that range from 1
--   to 16,384.
newtype Midi16384
Midi16384 :: PositiveInteger -> Midi16384
[midi16384] :: Midi16384 -> PositiveInteger
parseMidi16384 :: String -> XParse Midi16384

-- | <tt>millimeters</tt> <i>(simple)</i>
--   
--   The millimeters type is a number representing millimeters. This is
--   used in the scaling element to provide a default scaling from tenths
--   to physical units.
newtype Millimeters
Millimeters :: Decimal -> Millimeters
[millimeters] :: Millimeters -> Decimal
parseMillimeters :: String -> XParse Millimeters

-- | <tt>mode</tt> <i>(simple)</i>
--   
--   The mode type is used to specify major/minor and other mode
--   distinctions. Valid mode values include major, minor, dorian,
--   phrygian, lydian, mixolydian, aeolian, ionian, locrian, and none.
newtype Mode
Mode :: String -> Mode
[mode] :: Mode -> String
parseMode :: String -> XParse Mode

-- | <tt>mute</tt> <i>(simple)</i>
--   
--   The mute type represents muting for different instruments, including
--   brass, winds, and strings. The on and off values are used for
--   undifferentiated mutes. The remaining values represent specific mutes.
data Mute

-- | <i>on</i>
MuteOn :: Mute

-- | <i>off</i>
MuteOff :: Mute

-- | <i>straight</i>
MuteStraight :: Mute

-- | <i>cup</i>
MuteCup :: Mute

-- | <i>harmon-no-stem</i>
MuteHarmonNoStem :: Mute

-- | <i>harmon-stem</i>
MuteHarmonStem :: Mute

-- | <i>bucket</i>
MuteBucket :: Mute

-- | <i>plunger</i>
MutePlunger :: Mute

-- | <i>hat</i>
MuteHat :: Mute

-- | <i>solotone</i>
MuteSolotone :: Mute

-- | <i>practice</i>
MutePractice :: Mute

-- | <i>stop-mute</i>
MuteStopMute :: Mute

-- | <i>stop-hand</i>
MuteStopHand :: Mute

-- | <i>echo</i>
MuteEcho :: Mute

-- | <i>palm</i>
MutePalm :: Mute
parseMute :: String -> XParse Mute

-- | <tt>non-negative-decimal</tt> <i>(simple)</i>
--   
--   The non-negative-decimal type specifies a non-negative decimal value.
newtype NonNegativeDecimal
NonNegativeDecimal :: Decimal -> NonNegativeDecimal
[nonNegativeDecimal] :: NonNegativeDecimal -> Decimal
parseNonNegativeDecimal :: String -> XParse NonNegativeDecimal

-- | <tt>xs:nonNegativeInteger</tt> <i>(simple)</i>
newtype NonNegativeInteger
NonNegativeInteger :: Int -> NonNegativeInteger
[nonNegativeInteger] :: NonNegativeInteger -> Int
parseNonNegativeInteger :: String -> XParse NonNegativeInteger

-- | <tt>xs:normalizedString</tt> <i>(simple)</i>
newtype NormalizedString
NormalizedString :: String -> NormalizedString
[normalizedString] :: NormalizedString -> String
parseNormalizedString :: String -> XParse NormalizedString

-- | <tt>note-size-type</tt> <i>(simple)</i>
--   
--   The note-size-type type indicates the type of note being defined by a
--   note-size element. The grace-cue type is used for notes of grace-cue
--   size. The grace type is used for notes of cue size that include a
--   grace element. The cue type is used for all other notes with cue size,
--   whether defined explicitly or implicitly via a cue element. The large
--   type is used for notes of large size.
data NoteSizeType

-- | <i>cue</i>
NoteSizeTypeCue :: NoteSizeType

-- | <i>grace</i>
NoteSizeTypeGrace :: NoteSizeType

-- | <i>grace-cue</i>
NoteSizeTypeGraceCue :: NoteSizeType

-- | <i>large</i>
NoteSizeTypeLarge :: NoteSizeType
parseNoteSizeType :: String -> XParse NoteSizeType

-- | <tt>note-type-value</tt> <i>(simple)</i>
--   
--   The note-type type is used for the MusicXML type element and
--   represents the graphic note type, from 1024th (shortest) to maxima
--   (longest).
data NoteTypeValue

-- | <i>1024th</i>
NoteTypeValue1024th :: NoteTypeValue

-- | <i>512th</i>
NoteTypeValue512th :: NoteTypeValue

-- | <i>256th</i>
NoteTypeValue256th :: NoteTypeValue

-- | <i>128th</i>
NoteTypeValue128th :: NoteTypeValue

-- | <i>64th</i>
NoteTypeValue64th :: NoteTypeValue

-- | <i>32nd</i>
NoteTypeValue32nd :: NoteTypeValue

-- | <i>16th</i>
NoteTypeValue16th :: NoteTypeValue

-- | <i>eighth</i>
NoteTypeValueEighth :: NoteTypeValue

-- | <i>quarter</i>
NoteTypeValueQuarter :: NoteTypeValue

-- | <i>half</i>
NoteTypeValueHalf :: NoteTypeValue

-- | <i>whole</i>
NoteTypeValueWhole :: NoteTypeValue

-- | <i>breve</i>
NoteTypeValueBreve :: NoteTypeValue

-- | <i>long</i>
NoteTypeValueLong :: NoteTypeValue

-- | <i>maxima</i>
NoteTypeValueMaxima :: NoteTypeValue
parseNoteTypeValue :: String -> XParse NoteTypeValue

-- | <tt>notehead-value</tt> <i>(simple)</i>
--   
--   The notehead-value type indicates shapes other than the open and
--   closed ovals associated with note durations.
--   
--   The values do, re, mi, fa, fa up, so, la, and ti correspond to Aikin's
--   7-shape system. The fa up shape is typically used with upstems; the fa
--   shape is typically used with downstems or no stems.
--   
--   The arrow shapes differ from triangle and inverted triangle by being
--   centered on the stem. Slashed and back slashed notes include both the
--   normal notehead and a slash. The triangle shape has the tip of the
--   triangle pointing up; the inverted triangle shape has the tip of the
--   triangle pointing down. The left triangle shape is a right triangle
--   with the hypotenuse facing up and to the left.
--   
--   The other notehead covers noteheads other than those listed here. It
--   is usually used in combination with the smufl attribute to specify a
--   particular SMuFL notehead. The smufl attribute may be used with any
--   notehead value to help specify the appearance of symbols that share
--   the same MusicXML semantics. Noteheads in the SMuFL "Note name
--   noteheads" range (U+E150–U+E1AF) should not use the smufl attribute or
--   the "other" value, but instead use the notehead-text element.
data NoteheadValue

-- | <i>slash</i>
NoteheadValueSlash :: NoteheadValue

-- | <i>triangle</i>
NoteheadValueTriangle :: NoteheadValue

-- | <i>diamond</i>
NoteheadValueDiamond :: NoteheadValue

-- | <i>square</i>
NoteheadValueSquare :: NoteheadValue

-- | <i>cross</i>
NoteheadValueCross :: NoteheadValue

-- | <i>x</i>
NoteheadValueX :: NoteheadValue

-- | <i>circle-x</i>
NoteheadValueCircleX :: NoteheadValue

-- | <i>inverted triangle</i>
NoteheadValueInvertedTriangle :: NoteheadValue

-- | <i>arrow down</i>
NoteheadValueArrowDown :: NoteheadValue

-- | <i>arrow up</i>
NoteheadValueArrowUp :: NoteheadValue

-- | <i>circled</i>
NoteheadValueCircled :: NoteheadValue

-- | <i>slashed</i>
NoteheadValueSlashed :: NoteheadValue

-- | <i>back slashed</i>
NoteheadValueBackSlashed :: NoteheadValue

-- | <i>normal</i>
NoteheadValueNormal :: NoteheadValue

-- | <i>cluster</i>
NoteheadValueCluster :: NoteheadValue

-- | <i>circle dot</i>
NoteheadValueCircleDot :: NoteheadValue

-- | <i>left triangle</i>
NoteheadValueLeftTriangle :: NoteheadValue

-- | <i>rectangle</i>
NoteheadValueRectangle :: NoteheadValue

-- | <i>none</i>
NoteheadValueNone :: NoteheadValue

-- | <i>do</i>
NoteheadValueDo :: NoteheadValue

-- | <i>re</i>
NoteheadValueRe :: NoteheadValue

-- | <i>mi</i>
NoteheadValueMi :: NoteheadValue

-- | <i>fa</i>
NoteheadValueFa :: NoteheadValue

-- | <i>fa up</i>
NoteheadValueFaUp :: NoteheadValue

-- | <i>so</i>
NoteheadValueSo :: NoteheadValue

-- | <i>la</i>
NoteheadValueLa :: NoteheadValue

-- | <i>ti</i>
NoteheadValueTi :: NoteheadValue

-- | <i>other</i>
NoteheadValueOther :: NoteheadValue
parseNoteheadValue :: String -> XParse NoteheadValue

-- | <tt>number-level</tt> <i>(simple)</i>
--   
--   Slurs, tuplets, and many other features can be concurrent and
--   overlapping within a single musical part. The number-level type
--   distinguishes up to six concurrent objects of the same type. A reading
--   program should be prepared to handle cases where the number-levels
--   stop in an arbitrary order. Different numbers are needed when the
--   features overlap in MusicXML document order. When a number-level value
--   is optional, the value is 1 by default.
newtype NumberLevel
NumberLevel :: PositiveInteger -> NumberLevel
[numberLevel] :: NumberLevel -> PositiveInteger
parseNumberLevel :: String -> XParse NumberLevel

-- | <tt>number-of-lines</tt> <i>(simple)</i>
--   
--   The number-of-lines type is used to specify the number of lines in
--   text decoration attributes.
newtype NumberOfLines
NumberOfLines :: NonNegativeInteger -> NumberOfLines
[numberOfLines] :: NumberOfLines -> NonNegativeInteger
parseNumberOfLines :: String -> XParse NumberOfLines

-- | <tt>number-or-normal</tt> <i>(simple)</i>
--   
--   The number-or-normal values can be either a decimal number or the
--   string "normal". This is used by the line-height and letter-spacing
--   attributes.
data NumberOrNormal
NumberOrNormalDecimal :: Decimal -> NumberOrNormal
[numberOrNormal1] :: NumberOrNormal -> Decimal
NumberOrNormalNumberOrNormal :: SumNumberOrNormal -> NumberOrNormal
[numberOrNormal2] :: NumberOrNormal -> SumNumberOrNormal
parseNumberOrNormal :: String -> XParse NumberOrNormal

-- | <tt>octave</tt> <i>(simple)</i>
--   
--   Octaves are represented by the numbers 0 to 9, where 4 indicates the
--   octave started by middle C.
newtype Octave
Octave :: Int -> Octave
[octave] :: Octave -> Int
parseOctave :: String -> XParse Octave

-- | <tt>on-off</tt> <i>(simple)</i>
--   
--   The on-off type is used for notation elements such as string mutes.
data OnOff

-- | <i>on</i>
OnOffOn :: OnOff

-- | <i>off</i>
OnOffOff :: OnOff
parseOnOff :: String -> XParse OnOff

-- | <tt>over-under</tt> <i>(simple)</i>
--   
--   The over-under type is used to indicate whether the tips of curved
--   lines such as slurs and ties are overhand (tips down) or underhand
--   (tips up).
data OverUnder

-- | <i>over</i>
OverUnderOver :: OverUnder

-- | <i>under</i>
OverUnderUnder :: OverUnder
parseOverUnder :: String -> XParse OverUnder

-- | <tt>pedal-type</tt> <i>(simple)</i>
--   
--   The pedal-type simple type is used to distinguish types of pedal
--   directions. The start value indicates the start of a damper pedal,
--   while the sostenuto value indicates the start of a sostenuto pedal.
--   The change, continue, and stop values can be used with either the
--   damper or sostenuto pedal. The soft pedal is not included here because
--   there is no special symbol or graphic used for it beyond what can be
--   specified with words and bracket elements.
data PedalType

-- | <i>start</i>
PedalTypeStart :: PedalType

-- | <i>stop</i>
PedalTypeStop :: PedalType

-- | <i>sostenuto</i>
PedalTypeSostenuto :: PedalType

-- | <i>change</i>
PedalTypeChange :: PedalType

-- | <i>continue</i>
PedalTypeContinue :: PedalType
parsePedalType :: String -> XParse PedalType

-- | <tt>percent</tt> <i>(simple)</i>
--   
--   The percent type specifies a percentage from 0 to 100.
newtype Percent
Percent :: Decimal -> Percent
[percent] :: Percent -> Decimal
parsePercent :: String -> XParse Percent

-- | <tt>pitched-value</tt> <i>(simple)</i>
--   
--   The pitched-value type represents pictograms for pitched percussion
--   instruments. The chimes and tubular chimes values distinguish the
--   single-line and double-line versions of the pictogram.
data PitchedValue

-- | <i>celesta</i>
PitchedValueCelesta :: PitchedValue

-- | <i>chimes</i>
PitchedValueChimes :: PitchedValue

-- | <i>glockenspiel</i>
PitchedValueGlockenspiel :: PitchedValue

-- | <i>lithophone</i>
PitchedValueLithophone :: PitchedValue

-- | <i>mallet</i>
PitchedValueMallet :: PitchedValue

-- | <i>marimba</i>
PitchedValueMarimba :: PitchedValue

-- | <i>steel drums</i>
PitchedValueSteelDrums :: PitchedValue

-- | <i>tubaphone</i>
PitchedValueTubaphone :: PitchedValue

-- | <i>tubular chimes</i>
PitchedValueTubularChimes :: PitchedValue

-- | <i>vibraphone</i>
PitchedValueVibraphone :: PitchedValue

-- | <i>xylophone</i>
PitchedValueXylophone :: PitchedValue
parsePitchedValue :: String -> XParse PitchedValue

-- | <tt>positive-divisions</tt> <i>(simple)</i>
--   
--   The positive-divisions type restricts divisions values to positive
--   numbers.
newtype PositiveDivisions
PositiveDivisions :: Divisions -> PositiveDivisions
[positiveDivisions] :: PositiveDivisions -> Divisions
parsePositiveDivisions :: String -> XParse PositiveDivisions

-- | <tt>positive-integer-or-empty</tt> <i>(simple)</i>
--   
--   The positive-integer-or-empty values can be either a positive integer
--   or an empty string.
data PositiveIntegerOrEmpty
PositiveIntegerOrEmptyPositiveInteger :: PositiveInteger -> PositiveIntegerOrEmpty
[positiveIntegerOrEmpty1] :: PositiveIntegerOrEmpty -> PositiveInteger
PositiveIntegerOrEmptyPositiveIntegerOrEmpty :: SumPositiveIntegerOrEmpty -> PositiveIntegerOrEmpty
[positiveIntegerOrEmpty2] :: PositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty
parsePositiveIntegerOrEmpty :: String -> XParse PositiveIntegerOrEmpty

-- | <tt>xs:positiveInteger</tt> <i>(simple)</i>
newtype PositiveInteger
PositiveInteger :: NonNegativeInteger -> PositiveInteger
[positiveInteger] :: PositiveInteger -> NonNegativeInteger
parsePositiveInteger :: String -> XParse PositiveInteger

-- | <tt>principal-voice-symbol</tt> <i>(simple)</i>
--   
--   The principal-voice-symbol type represents the type of symbol used to
--   indicate the start of a principal or secondary voice. The "plain"
--   value represents a plain square bracket. The value of "none" is used
--   for analysis markup when the principal-voice element does not have a
--   corresponding appearance in the score.
data PrincipalVoiceSymbol

-- | <i>Hauptstimme</i>
PrincipalVoiceSymbolHauptstimme :: PrincipalVoiceSymbol

-- | <i>Nebenstimme</i>
PrincipalVoiceSymbolNebenstimme :: PrincipalVoiceSymbol

-- | <i>plain</i>
PrincipalVoiceSymbolPlain :: PrincipalVoiceSymbol

-- | <i>none</i>
PrincipalVoiceSymbolNone :: PrincipalVoiceSymbol
parsePrincipalVoiceSymbol :: String -> XParse PrincipalVoiceSymbol

-- | <tt>right-left-middle</tt> <i>(simple)</i>
--   
--   The right-left-middle type is used to specify barline location.
data RightLeftMiddle

-- | <i>right</i>
RightLeftMiddleRight :: RightLeftMiddle

-- | <i>left</i>
RightLeftMiddleLeft :: RightLeftMiddle

-- | <i>middle</i>
RightLeftMiddleMiddle :: RightLeftMiddle
parseRightLeftMiddle :: String -> XParse RightLeftMiddle

-- | <tt>rotation-degrees</tt> <i>(simple)</i>
--   
--   The rotation-degrees type specifies rotation, pan, and elevation
--   values in degrees. Values range from -180 to 180.
newtype RotationDegrees
RotationDegrees :: Decimal -> RotationDegrees
[rotationDegrees] :: RotationDegrees -> Decimal
parseRotationDegrees :: String -> XParse RotationDegrees

-- | <tt>semi-pitched</tt> <i>(simple)</i>
--   
--   The semi-pitched type represents categories of indefinite pitch for
--   percussion instruments.
data SemiPitched

-- | <i>high</i>
SemiPitchedHigh :: SemiPitched

-- | <i>medium-high</i>
SemiPitchedMediumHigh :: SemiPitched

-- | <i>medium</i>
SemiPitchedMedium :: SemiPitched

-- | <i>medium-low</i>
SemiPitchedMediumLow :: SemiPitched

-- | <i>low</i>
SemiPitchedLow :: SemiPitched

-- | <i>very-low</i>
SemiPitchedVeryLow :: SemiPitched
parseSemiPitched :: String -> XParse SemiPitched

-- | <tt>semitones</tt> <i>(simple)</i>
--   
--   The semitones type is a number representing semitones, used for
--   chromatic alteration. A value of -1 corresponds to a flat and a value
--   of 1 to a sharp. Decimal values like 0.5 (quarter tone sharp) are used
--   for microtones.
newtype Semitones
Semitones :: Decimal -> Semitones
[semitones] :: Semitones -> Decimal
parseSemitones :: String -> XParse Semitones

-- | <tt>xlink:show</tt> <i>(simple)</i>
data SmpShow

-- | <i>new</i>
ShowNew :: SmpShow

-- | <i>replace</i>
ShowReplace :: SmpShow

-- | <i>embed</i>
ShowEmbed :: SmpShow

-- | <i>other</i>
ShowOther :: SmpShow

-- | <i>none</i>
ShowNone :: SmpShow
parseSmpShow :: String -> XParse SmpShow

-- | <tt>show-frets</tt> <i>(simple)</i>
--   
--   The show-frets type indicates whether to show tablature frets as
--   numbers (0, 1, 2) or letters (a, b, c). The default choice is numbers.
data ShowFrets

-- | <i>numbers</i>
ShowFretsNumbers :: ShowFrets

-- | <i>letters</i>
ShowFretsLetters :: ShowFrets
parseShowFrets :: String -> XParse ShowFrets

-- | <tt>show-tuplet</tt> <i>(simple)</i>
--   
--   The show-tuplet type indicates whether to show a part of a tuplet
--   relating to the tuplet-actual element, both the tuplet-actual and
--   tuplet-normal elements, or neither.
data ShowTuplet

-- | <i>actual</i>
ShowTupletActual :: ShowTuplet

-- | <i>both</i>
ShowTupletBoth :: ShowTuplet

-- | <i>none</i>
ShowTupletNone :: ShowTuplet
parseShowTuplet :: String -> XParse ShowTuplet

-- | <tt>smufl-accidental-glyph-name</tt> <i>(simple)</i>
--   
--   The smufl-accidental-glyph-name type is used to reference a specific
--   Standard Music Font Layout (SMuFL) accidental character. The value is
--   a SMuFL canonical glyph name that starts with acc.
newtype SmuflAccidentalGlyphName
SmuflAccidentalGlyphName :: SmuflGlyphName -> SmuflAccidentalGlyphName
[smuflAccidentalGlyphName] :: SmuflAccidentalGlyphName -> SmuflGlyphName
parseSmuflAccidentalGlyphName :: String -> XParse SmuflAccidentalGlyphName

-- | <tt>smufl-coda-glyph-name</tt> <i>(simple)</i>
--   
--   The smufl-coda-glyph-name type is used to reference a specific
--   Standard Music Font Layout (SMuFL) coda character. The value is a
--   SMuFL canonical glyph name that starts with coda.
newtype SmuflCodaGlyphName
SmuflCodaGlyphName :: SmuflGlyphName -> SmuflCodaGlyphName
[smuflCodaGlyphName] :: SmuflCodaGlyphName -> SmuflGlyphName
parseSmuflCodaGlyphName :: String -> XParse SmuflCodaGlyphName

-- | <tt>smufl-glyph-name</tt> <i>(simple)</i>
--   
--   The smufl-glyph-name type is used for attributes that reference a
--   specific Standard Music Font Layout (SMuFL) character. The value is a
--   SMuFL canonical glyph name, not a code point. For instance, the value
--   for a standard piano pedal mark would be keyboardPedalPed, not U+E650.
newtype SmuflGlyphName
SmuflGlyphName :: NMTOKEN -> SmuflGlyphName
[smuflGlyphName] :: SmuflGlyphName -> NMTOKEN
parseSmuflGlyphName :: String -> XParse SmuflGlyphName

-- | <tt>smufl-lyrics-glyph-name</tt> <i>(simple)</i>
--   
--   The smufl-lyrics-glyph-name type is used to reference a specific
--   Standard Music Font Layout (SMuFL) lyrics elision character. The value
--   is a SMuFL canonical glyph name that starts with lyrics.
newtype SmuflLyricsGlyphName
SmuflLyricsGlyphName :: SmuflGlyphName -> SmuflLyricsGlyphName
[smuflLyricsGlyphName] :: SmuflLyricsGlyphName -> SmuflGlyphName
parseSmuflLyricsGlyphName :: String -> XParse SmuflLyricsGlyphName

-- | <tt>smufl-pictogram-glyph-name</tt> <i>(simple)</i>
--   
--   The smufl-pictogram-glyph-name type is used to reference a specific
--   Standard Music Font Layout (SMuFL) percussion pictogram character. The
--   value is a SMuFL canonical glyph name that starts with pict.
newtype SmuflPictogramGlyphName
SmuflPictogramGlyphName :: SmuflGlyphName -> SmuflPictogramGlyphName
[smuflPictogramGlyphName] :: SmuflPictogramGlyphName -> SmuflGlyphName
parseSmuflPictogramGlyphName :: String -> XParse SmuflPictogramGlyphName

-- | <tt>smufl-segno-glyph-name</tt> <i>(simple)</i>
--   
--   The smufl-segno-glyph-name type is used to reference a specific
--   Standard Music Font Layout (SMuFL) segno character. The value is a
--   SMuFL canonical glyph name that starts with segno.
newtype SmuflSegnoGlyphName
SmuflSegnoGlyphName :: SmuflGlyphName -> SmuflSegnoGlyphName
[smuflSegnoGlyphName] :: SmuflSegnoGlyphName -> SmuflGlyphName
parseSmuflSegnoGlyphName :: String -> XParse SmuflSegnoGlyphName

-- | <tt>xml:space</tt> <i>(simple)</i>
data Space

-- | <i>default</i>
SpaceDefault :: Space

-- | <i>preserve</i>
SpacePreserve :: Space
parseSpace :: String -> XParse Space

-- | <tt>staff-divide-symbol</tt> <i>(simple)</i>
--   
--   The staff-divide-symbol type is used for staff division symbols. The
--   down, up, and up-down values correspond to SMuFL code points U+E00B,
--   U+E00C, and U+E00D respectively.
data StaffDivideSymbol

-- | <i>down</i>
StaffDivideSymbolDown :: StaffDivideSymbol

-- | <i>up</i>
StaffDivideSymbolUp :: StaffDivideSymbol

-- | <i>up-down</i>
StaffDivideSymbolUpDown :: StaffDivideSymbol
parseStaffDivideSymbol :: String -> XParse StaffDivideSymbol

-- | <tt>staff-line</tt> <i>(simple)</i>
--   
--   The staff-line type indicates the line on a given staff. Staff lines
--   are numbered from bottom to top, with 1 being the bottom line on a
--   staff. Staff line values can be used to specify positions outside the
--   staff, such as a C clef positioned in the middle of a grand staff.
newtype StaffLine
StaffLine :: Int -> StaffLine
[staffLine] :: StaffLine -> Int
parseStaffLine :: String -> XParse StaffLine

-- | <tt>staff-number</tt> <i>(simple)</i>
--   
--   The staff-number type indicates staff numbers within a multi-staff
--   part. Staves are numbered from top to bottom, with 1 being the top
--   staff on a part.
newtype StaffNumber
StaffNumber :: PositiveInteger -> StaffNumber
[staffNumber] :: StaffNumber -> PositiveInteger
parseStaffNumber :: String -> XParse StaffNumber

-- | <tt>staff-type</tt> <i>(simple)</i>
--   
--   The staff-type value can be ossia, cue, editorial, regular, or
--   alternate. An alternate staff indicates one that shares the same
--   musical data as the prior staff, but displayed differently (e.g.,
--   treble and bass clef, standard notation and tab).
data StaffType

-- | <i>ossia</i>
StaffTypeOssia :: StaffType

-- | <i>cue</i>
StaffTypeCue :: StaffType

-- | <i>editorial</i>
StaffTypeEditorial :: StaffType

-- | <i>regular</i>
StaffTypeRegular :: StaffType

-- | <i>alternate</i>
StaffTypeAlternate :: StaffType
parseStaffType :: String -> XParse StaffType

-- | <tt>start-note</tt> <i>(simple)</i>
--   
--   The start-note type describes the starting note of trills and mordents
--   for playback, relative to the current note.
data StartNote

-- | <i>upper</i>
StartNoteUpper :: StartNote

-- | <i>main</i>
StartNoteMain :: StartNote

-- | <i>below</i>
StartNoteBelow :: StartNote
parseStartNote :: String -> XParse StartNote

-- | <tt>start-stop</tt> <i>(simple)</i>
--   
--   The start-stop type is used for an attribute of musical elements that
--   can either start or stop, such as tuplets.
--   
--   The values of start and stop refer to how an element appears in
--   musical score order, not in MusicXML document order. An element with a
--   stop attribute may precede the corresponding element with a start
--   attribute within a MusicXML document. This is particularly common in
--   multi-staff music. For example, the stopping point for a tuplet may
--   appear in staff 1 before the starting point for the tuplet appears in
--   staff 2 later in the document.
data StartStop

-- | <i>start</i>
StartStopStart :: StartStop

-- | <i>stop</i>
StartStopStop :: StartStop
parseStartStop :: String -> XParse StartStop

-- | <tt>start-stop-continue</tt> <i>(simple)</i>
--   
--   The start-stop-continue type is used for an attribute of musical
--   elements that can either start or stop, but also need to refer to an
--   intermediate point in the symbol, as for complex slurs or for
--   formatting of symbols across system breaks.
--   
--   The values of start, stop, and continue refer to how an element
--   appears in musical score order, not in MusicXML document order. An
--   element with a stop attribute may precede the corresponding element
--   with a start attribute within a MusicXML document. This is
--   particularly common in multi-staff music. For example, the stopping
--   point for a slur may appear in staff 1 before the starting point for
--   the slur appears in staff 2 later in the document.
data StartStopContinue

-- | <i>start</i>
StartStopContinueStart :: StartStopContinue

-- | <i>stop</i>
StartStopContinueStop :: StartStopContinue

-- | <i>continue</i>
StartStopContinueContinue :: StartStopContinue
parseStartStopContinue :: String -> XParse StartStopContinue

-- | <tt>start-stop-discontinue</tt> <i>(simple)</i>
--   
--   The start-stop-discontinue type is used to specify ending types.
--   Typically, the start type is associated with the left barline of the
--   first measure in an ending. The stop and discontinue types are
--   associated with the right barline of the last measure in an ending.
--   Stop is used when the ending mark concludes with a downward jog, as is
--   typical for first endings. Discontinue is used when there is no
--   downward jog, as is typical for second endings that do not conclude a
--   piece.
data StartStopDiscontinue

-- | <i>start</i>
StartStopDiscontinueStart :: StartStopDiscontinue

-- | <i>stop</i>
StartStopDiscontinueStop :: StartStopDiscontinue

-- | <i>discontinue</i>
StartStopDiscontinueDiscontinue :: StartStopDiscontinue
parseStartStopDiscontinue :: String -> XParse StartStopDiscontinue

-- | <tt>start-stop-single</tt> <i>(simple)</i>
--   
--   The start-stop-single type is used for an attribute of musical
--   elements that can be used for either multi-note or single-note musical
--   elements, as for groupings.
data StartStopSingle

-- | <i>start</i>
StartStopSingleStart :: StartStopSingle

-- | <i>stop</i>
StartStopSingleStop :: StartStopSingle

-- | <i>single</i>
StartStopSingleSingle :: StartStopSingle
parseStartStopSingle :: String -> XParse StartStopSingle

-- | <tt>stem-value</tt> <i>(simple)</i>
--   
--   The stem type represents the notated stem direction.
data StemValue

-- | <i>down</i>
StemValueDown :: StemValue

-- | <i>up</i>
StemValueUp :: StemValue

-- | <i>double</i>
StemValueDouble :: StemValue

-- | <i>none</i>
StemValueNone :: StemValue
parseStemValue :: String -> XParse StemValue

-- | <tt>step</tt> <i>(simple)</i>
--   
--   The step type represents a step of the diatonic scale, represented
--   using the English letters A through G.
data Step

-- | <i>A</i>
StepA :: Step

-- | <i>B</i>
StepB :: Step

-- | <i>C</i>
StepC :: Step

-- | <i>D</i>
StepD :: Step

-- | <i>E</i>
StepE :: Step

-- | <i>F</i>
StepF :: Step

-- | <i>G</i>
StepG :: Step
parseStep :: String -> XParse Step

-- | <tt>stick-location</tt> <i>(simple)</i>
--   
--   The stick-location type represents pictograms for the location of
--   sticks, beaters, or mallets on cymbals, gongs, drums, and other
--   instruments.
data StickLocation

-- | <i>center</i>
StickLocationCenter :: StickLocation

-- | <i>rim</i>
StickLocationRim :: StickLocation

-- | <i>cymbal bell</i>
StickLocationCymbalBell :: StickLocation

-- | <i>cymbal edge</i>
StickLocationCymbalEdge :: StickLocation
parseStickLocation :: String -> XParse StickLocation

-- | <tt>stick-material</tt> <i>(simple)</i>
--   
--   The stick-material type represents the material being displayed in a
--   stick pictogram.
data StickMaterial

-- | <i>soft</i>
StickMaterialSoft :: StickMaterial

-- | <i>medium</i>
StickMaterialMedium :: StickMaterial

-- | <i>hard</i>
StickMaterialHard :: StickMaterial

-- | <i>shaded</i>
StickMaterialShaded :: StickMaterial

-- | <i>x</i>
StickMaterialX :: StickMaterial
parseStickMaterial :: String -> XParse StickMaterial

-- | <tt>stick-type</tt> <i>(simple)</i>
--   
--   The stick-type type represents the shape of pictograms where the
--   material in the stick, mallet, or beater is represented in the
--   pictogram.
data StickType

-- | <i>bass drum</i>
StickTypeBassDrum :: StickType

-- | <i>double bass drum</i>
StickTypeDoubleBassDrum :: StickType

-- | <i>glockenspiel</i>
StickTypeGlockenspiel :: StickType

-- | <i>gum</i>
StickTypeGum :: StickType

-- | <i>hammer</i>
StickTypeHammer :: StickType

-- | <i>superball</i>
StickTypeSuperball :: StickType

-- | <i>timpani</i>
StickTypeTimpani :: StickType

-- | <i>wound</i>
StickTypeWound :: StickType

-- | <i>xylophone</i>
StickTypeXylophone :: StickType

-- | <i>yarn</i>
StickTypeYarn :: StickType
parseStickType :: String -> XParse StickType

-- | <tt>string-number</tt> <i>(simple)</i>
--   
--   The string-number type indicates a string number. Strings are numbered
--   from high to low, with 1 being the highest pitched full-length string.
newtype StringNumber
StringNumber :: PositiveInteger -> StringNumber
[stringNumber] :: StringNumber -> PositiveInteger
parseStringNumber :: String -> XParse StringNumber

-- | <tt>syllabic</tt> <i>(simple)</i>
--   
--   Lyric hyphenation is indicated by the syllabic type. The single,
--   begin, end, and middle values represent single-syllable words,
--   word-beginning syllables, word-ending syllables, and mid-word
--   syllables, respectively.
data Syllabic

-- | <i>single</i>
SyllabicSingle :: Syllabic

-- | <i>begin</i>
SyllabicBegin :: Syllabic

-- | <i>end</i>
SyllabicEnd :: Syllabic

-- | <i>middle</i>
SyllabicMiddle :: Syllabic
parseSyllabic :: String -> XParse Syllabic

-- | <tt>symbol-size</tt> <i>(simple)</i>
--   
--   The symbol-size type is used to distinguish between full, cue sized,
--   grace cue sized, and oversized symbols.
data SymbolSize

-- | <i>full</i>
SymbolSizeFull :: SymbolSize

-- | <i>cue</i>
SymbolSizeCue :: SymbolSize

-- | <i>grace-cue</i>
SymbolSizeGraceCue :: SymbolSize

-- | <i>large</i>
SymbolSizeLarge :: SymbolSize
parseSymbolSize :: String -> XParse SymbolSize

-- | <tt>tap-hand</tt> <i>(simple)</i>
--   
--   The tap-hand type represents the symbol to use for a tap element. The
--   left and right values refer to the SMuFL guitarLeftHandTapping and
--   guitarRightHandTapping glyphs respectively.
data TapHand

-- | <i>left</i>
TapHandLeft :: TapHand

-- | <i>right</i>
TapHandRight :: TapHand
parseTapHand :: String -> XParse TapHand

-- | <tt>tenths</tt> <i>(simple)</i>
--   
--   The tenths type is a number representing tenths of interline staff
--   space (positive or negative). Both integer and decimal values are
--   allowed, such as 5 for a half space and 2.5 for a quarter space.
--   Interline space is measured from the middle of a staff line.
--   
--   Distances in a MusicXML file are measured in tenths of staff space.
--   Tenths are then scaled to millimeters within the scaling element, used
--   in the defaults element at the start of a score. Individual staves can
--   apply a scaling factor to adjust staff size. When a MusicXML element
--   or attribute refers to tenths, it means the global tenths defined by
--   the scaling element, not the local tenths as adjusted by the
--   staff-size element.
newtype Tenths
Tenths :: Decimal -> Tenths
[tenths] :: Tenths -> Decimal
parseTenths :: String -> XParse Tenths

-- | <tt>text-direction</tt> <i>(simple)</i>
--   
--   The text-direction type is used to adjust and override the Unicode
--   bidirectional text algorithm, similar to the W3C Internationalization
--   Tag Set recommendation. Values are ltr (left-to-right embed), rtl
--   (right-to-left embed), lro (left-to-right bidi-override), and rlo
--   (right-to-left bidi-override). The default value is ltr. This type is
--   typically used by applications that store text in left-to-right visual
--   order rather than logical order. Such applications can use the lro
--   value to better communicate with other applications that more fully
--   support bidirectional text.
data TextDirection

-- | <i>ltr</i>
TextDirectionLtr :: TextDirection

-- | <i>rtl</i>
TextDirectionRtl :: TextDirection

-- | <i>lro</i>
TextDirectionLro :: TextDirection

-- | <i>rlo</i>
TextDirectionRlo :: TextDirection
parseTextDirection :: String -> XParse TextDirection

-- | <tt>tied-type</tt> <i>(simple)</i>
--   
--   The tied-type type is used as an attribute of the tied element to
--   specify where the visual representation of a tie begins and ends. A
--   tied element which joins two notes of the same pitch can be specified
--   with tied-type start on the first note and tied-type stop on the
--   second note. To indicate a note should be undamped, use a single tied
--   element with tied-type let-ring. For other ties that are visually
--   attached to a single note, such as a tie leading into or out of a
--   repeated section or coda, use two tied elements on the same note, one
--   start and one stop.
--   
--   In start-stop cases, ties can add more elements using a continue type.
--   This is typically used to specify the formatting of cross-system ties.
data TiedType

-- | <i>start</i>
TiedTypeStart :: TiedType

-- | <i>stop</i>
TiedTypeStop :: TiedType

-- | <i>continue</i>
TiedTypeContinue :: TiedType

-- | <i>let-ring</i>
TiedTypeLetRing :: TiedType
parseTiedType :: String -> XParse TiedType

-- | <tt>time-only</tt> <i>(simple)</i>
--   
--   The time-only type is used to indicate that a particular
--   playback-related element only applies particular times through a
--   repeated section. The value is a comma-separated list of positive
--   integers arranged in ascending order, indicating which times through
--   the repeated section that the element applies.
newtype TimeOnly
TimeOnly :: Token -> TimeOnly
[timeOnly] :: TimeOnly -> Token
parseTimeOnly :: String -> XParse TimeOnly

-- | <tt>time-relation</tt> <i>(simple)</i>
--   
--   The time-relation type indicates the symbol used to represent the
--   interchangeable aspect of dual time signatures.
data TimeRelation

-- | <i>parentheses</i>
TimeRelationParentheses :: TimeRelation

-- | <i>bracket</i>
TimeRelationBracket :: TimeRelation

-- | <i>equals</i>
TimeRelationEquals :: TimeRelation

-- | <i>slash</i>
TimeRelationSlash :: TimeRelation

-- | <i>space</i>
TimeRelationSpace :: TimeRelation

-- | <i>hyphen</i>
TimeRelationHyphen :: TimeRelation
parseTimeRelation :: String -> XParse TimeRelation

-- | <tt>time-separator</tt> <i>(simple)</i>
--   
--   The time-separator type indicates how to display the arrangement
--   between the beats and beat-type values in a time signature. The
--   default value is none. The horizontal, diagonal, and vertical values
--   represent horizontal, diagonal lower-left to upper-right, and vertical
--   lines respectively. For these values, the beats and beat-type values
--   are arranged on either side of the separator line. The none value
--   represents no separator with the beats and beat-type arranged
--   vertically. The adjacent value represents no separator with the beats
--   and beat-type arranged horizontally.
data TimeSeparator

-- | <i>none</i>
TimeSeparatorNone :: TimeSeparator

-- | <i>horizontal</i>
TimeSeparatorHorizontal :: TimeSeparator

-- | <i>diagonal</i>
TimeSeparatorDiagonal :: TimeSeparator

-- | <i>vertical</i>
TimeSeparatorVertical :: TimeSeparator

-- | <i>adjacent</i>
TimeSeparatorAdjacent :: TimeSeparator
parseTimeSeparator :: String -> XParse TimeSeparator

-- | <tt>time-symbol</tt> <i>(simple)</i>
--   
--   The time-symbol type indicates how to display a time signature. The
--   normal value is the usual fractional display, and is the implied
--   symbol type if none is specified. Other options are the common and cut
--   time symbols, as well as a single number with an implied denominator.
--   The note symbol indicates that the beat-type should be represented
--   with the corresponding downstem note rather than a number. The
--   dotted-note symbol indicates that the beat-type should be represented
--   with a dotted downstem note that corresponds to three times the
--   beat-type value, and a numerator that is one third the beats value.
data TimeSymbol

-- | <i>common</i>
TimeSymbolCommon :: TimeSymbol

-- | <i>cut</i>
TimeSymbolCut :: TimeSymbol

-- | <i>single-number</i>
TimeSymbolSingleNumber :: TimeSymbol

-- | <i>note</i>
TimeSymbolNote :: TimeSymbol

-- | <i>dotted-note</i>
TimeSymbolDottedNote :: TimeSymbol

-- | <i>normal</i>
TimeSymbolNormal :: TimeSymbol
parseTimeSymbol :: String -> XParse TimeSymbol

-- | <tt>tip-direction</tt> <i>(simple)</i>
--   
--   The tip-direction type represents the direction in which the tip of a
--   stick or beater points, using Unicode arrow terminology.
data TipDirection

-- | <i>up</i>
TipDirectionUp :: TipDirection

-- | <i>down</i>
TipDirectionDown :: TipDirection

-- | <i>left</i>
TipDirectionLeft :: TipDirection

-- | <i>right</i>
TipDirectionRight :: TipDirection

-- | <i>northwest</i>
TipDirectionNorthwest :: TipDirection

-- | <i>northeast</i>
TipDirectionNortheast :: TipDirection

-- | <i>southeast</i>
TipDirectionSoutheast :: TipDirection

-- | <i>southwest</i>
TipDirectionSouthwest :: TipDirection
parseTipDirection :: String -> XParse TipDirection

-- | <tt>xs:token</tt> <i>(simple)</i>
newtype Token
Token :: NormalizedString -> Token
[token] :: Token -> NormalizedString
parseToken :: String -> XParse Token

-- | <tt>top-bottom</tt> <i>(simple)</i>
--   
--   The top-bottom type is used to indicate the top or bottom part of a
--   vertical shape like non-arpeggiate.
data TopBottom

-- | <i>top</i>
TopBottomTop :: TopBottom

-- | <i>bottom</i>
TopBottomBottom :: TopBottom
parseTopBottom :: String -> XParse TopBottom

-- | <tt>tremolo-marks</tt> <i>(simple)</i>
--   
--   The number of tremolo marks is represented by a number from 0 to 8:
--   the same as beam-level with 0 added.
newtype TremoloMarks
TremoloMarks :: Int -> TremoloMarks
[tremoloMarks] :: TremoloMarks -> Int
parseTremoloMarks :: String -> XParse TremoloMarks

-- | <tt>tremolo-type</tt> <i>(simple)</i>
--   
--   The tremolo-type is used to distinguish multi-note, single-note, and
--   unmeasured tremolos.
data TremoloType

-- | <i>start</i>
TremoloTypeStart :: TremoloType

-- | <i>stop</i>
TremoloTypeStop :: TremoloType

-- | <i>single</i>
TremoloTypeSingle :: TremoloType

-- | <i>unmeasured</i>
TremoloTypeUnmeasured :: TremoloType
parseTremoloType :: String -> XParse TremoloType

-- | <tt>trill-beats</tt> <i>(simple)</i>
--   
--   The trill-beats type specifies the beats used in a trill-sound or
--   bend-sound attribute group. It is a decimal value with a minimum value
--   of 2.
newtype TrillBeats
TrillBeats :: Decimal -> TrillBeats
[trillBeats] :: TrillBeats -> Decimal
parseTrillBeats :: String -> XParse TrillBeats

-- | <tt>trill-step</tt> <i>(simple)</i>
--   
--   The trill-step type describes the alternating note of trills and
--   mordents for playback, relative to the current note.
data TrillStep

-- | <i>whole</i>
TrillStepWhole :: TrillStep

-- | <i>half</i>
TrillStepHalf :: TrillStep

-- | <i>unison</i>
TrillStepUnison :: TrillStep
parseTrillStep :: String -> XParse TrillStep

-- | <tt>two-note-turn</tt> <i>(simple)</i>
--   
--   The two-note-turn type describes the ending notes of trills and
--   mordents for playback, relative to the current note.
data TwoNoteTurn

-- | <i>whole</i>
TwoNoteTurnWhole :: TwoNoteTurn

-- | <i>half</i>
TwoNoteTurnHalf :: TwoNoteTurn

-- | <i>none</i>
TwoNoteTurnNone :: TwoNoteTurn
parseTwoNoteTurn :: String -> XParse TwoNoteTurn

-- | <tt>xlink:type</tt> <i>(simple)</i>
data Type

-- | <i>simple</i>
TypeSimple :: Type
parseType :: String -> XParse Type

-- | <tt>up-down</tt> <i>(simple)</i>
--   
--   The up-down type is used for the direction of arrows and other pointed
--   symbols like vertical accents, indicating which way the tip is
--   pointing.
data UpDown

-- | <i>up</i>
UpDownUp :: UpDown

-- | <i>down</i>
UpDownDown :: UpDown
parseUpDown :: String -> XParse UpDown

-- | <tt>up-down-stop-continue</tt> <i>(simple)</i>
--   
--   The up-down-stop-continue type is used for octave-shift elements,
--   indicating the direction of the shift from their true pitched values
--   because of printing difficulty.
data UpDownStopContinue

-- | <i>up</i>
UpDownStopContinueUp :: UpDownStopContinue

-- | <i>down</i>
UpDownStopContinueDown :: UpDownStopContinue

-- | <i>stop</i>
UpDownStopContinueStop :: UpDownStopContinue

-- | <i>continue</i>
UpDownStopContinueContinue :: UpDownStopContinue
parseUpDownStopContinue :: String -> XParse UpDownStopContinue

-- | <tt>upright-inverted</tt> <i>(simple)</i>
--   
--   The upright-inverted type describes the appearance of a fermata
--   element. The value is upright if not specified.
data UprightInverted

-- | <i>upright</i>
UprightInvertedUpright :: UprightInverted

-- | <i>inverted</i>
UprightInvertedInverted :: UprightInverted
parseUprightInverted :: String -> XParse UprightInverted

-- | <tt>valign</tt> <i>(simple)</i>
--   
--   The valign type is used to indicate vertical alignment to the top,
--   middle, bottom, or baseline of the text. Defaults are
--   implementation-dependent.
data Valign

-- | <i>top</i>
ValignTop :: Valign

-- | <i>middle</i>
ValignMiddle :: Valign

-- | <i>bottom</i>
ValignBottom :: Valign

-- | <i>baseline</i>
ValignBaseline :: Valign
parseValign :: String -> XParse Valign

-- | <tt>valign-image</tt> <i>(simple)</i>
--   
--   The valign-image type is used to indicate vertical alignment for
--   images and graphics, so it does not include a baseline value. Defaults
--   are implementation-dependent.
data ValignImage

-- | <i>top</i>
ValignImageTop :: ValignImage

-- | <i>middle</i>
ValignImageMiddle :: ValignImage

-- | <i>bottom</i>
ValignImageBottom :: ValignImage
parseValignImage :: String -> XParse ValignImage

-- | <tt>wedge-type</tt> <i>(simple)</i>
--   
--   The wedge type is crescendo for the start of a wedge that is closed at
--   the left side, diminuendo for the start of a wedge that is closed on
--   the right side, and stop for the end of a wedge. The continue type is
--   used for formatting wedges over a system break, or for other
--   situations where a single wedge is divided into multiple segments.
data WedgeType

-- | <i>crescendo</i>
WedgeTypeCrescendo :: WedgeType

-- | <i>diminuendo</i>
WedgeTypeDiminuendo :: WedgeType

-- | <i>stop</i>
WedgeTypeStop :: WedgeType

-- | <i>continue</i>
WedgeTypeContinue :: WedgeType
parseWedgeType :: String -> XParse WedgeType

-- | <tt>winged</tt> <i>(simple)</i>
--   
--   The winged attribute indicates whether the repeat has winged
--   extensions that appear above and below the barline. The straight and
--   curved values represent single wings, while the double-straight and
--   double-curved values represent double wings. The none value indicates
--   no wings and is the default.
data Winged

-- | <i>none</i>
WingedNone :: Winged

-- | <i>straight</i>
WingedStraight :: Winged

-- | <i>curved</i>
WingedCurved :: Winged

-- | <i>double-straight</i>
WingedDoubleStraight :: Winged

-- | <i>double-curved</i>
WingedDoubleCurved :: Winged
parseWinged :: String -> XParse Winged

-- | <tt>wood</tt> <i>(simple)</i>
--   
--   The wood type represents pictograms for wood percussion instruments.
--   The maraca and maracas values distinguish the one- and two-maraca
--   versions of the pictogram.
data Wood

-- | <i>bamboo scraper</i>
WoodBambooScraper :: Wood

-- | <i>board clapper</i>
WoodBoardClapper :: Wood

-- | <i>cabasa</i>
WoodCabasa :: Wood

-- | <i>castanets</i>
WoodCastanets :: Wood

-- | <i>castanets with handle</i>
WoodCastanetsWithHandle :: Wood

-- | <i>claves</i>
WoodClaves :: Wood

-- | <i>football rattle</i>
WoodFootballRattle :: Wood

-- | <i>guiro</i>
WoodGuiro :: Wood

-- | <i>log drum</i>
WoodLogDrum :: Wood

-- | <i>maraca</i>
WoodMaraca :: Wood

-- | <i>maracas</i>
WoodMaracas :: Wood

-- | <i>quijada</i>
WoodQuijada :: Wood

-- | <i>rainstick</i>
WoodRainstick :: Wood

-- | <i>ratchet</i>
WoodRatchet :: Wood

-- | <i>reco-reco</i>
WoodRecoReco :: Wood

-- | <i>sandpaper blocks</i>
WoodSandpaperBlocks :: Wood

-- | <i>slit drum</i>
WoodSlitDrum :: Wood

-- | <i>temple block</i>
WoodTempleBlock :: Wood

-- | <i>vibraslap</i>
WoodVibraslap :: Wood

-- | <i>whip</i>
WoodWhip :: Wood

-- | <i>wood block</i>
WoodWoodBlock :: Wood
parseWood :: String -> XParse Wood

-- | <tt>yes-no</tt> <i>(simple)</i>
--   
--   The yes-no type is used for boolean-like attributes. We cannot use W3C
--   XML Schema booleans due to their restrictions on expression of boolean
--   values.
data YesNo

-- | <i>yes</i>
YesNoYes :: YesNo

-- | <i>no</i>
YesNoNo :: YesNo
parseYesNo :: String -> XParse YesNo

-- | <tt>yes-no-number</tt> <i>(simple)</i>
--   
--   The yes-no-number type is used for attributes that can be either
--   boolean or numeric values.
data YesNoNumber
YesNoNumberYesNo :: YesNo -> YesNoNumber
[yesNoNumber1] :: YesNoNumber -> YesNo
YesNoNumberDecimal :: Decimal -> YesNoNumber
[yesNoNumber2] :: YesNoNumber -> Decimal
parseYesNoNumber :: String -> XParse YesNoNumber

-- | <tt>yyyy-mm-dd</tt> <i>(simple)</i>
--   
--   Calendar dates are represented yyyy-mm-dd format, following ISO 8601.
--   This is a W3C XML Schema date type, but without the optional timezone
--   data.
newtype YyyyMmDd
YyyyMmDd :: String -> YyyyMmDd
[yyyyMmDd] :: YyyyMmDd -> String
parseYyyyMmDd :: String -> XParse YyyyMmDd

-- | <tt>xml:lang</tt> <i>(union)</i>
data SumLang

-- | //
SumLang :: SumLang
parseSumLang :: String -> XParse SumLang

-- | <tt>number-or-normal</tt> <i>(union)</i>
data SumNumberOrNormal

-- | <i>normal</i>
NumberOrNormalNormal :: SumNumberOrNormal
parseSumNumberOrNormal :: String -> XParse SumNumberOrNormal

-- | <tt>positive-integer-or-empty</tt> <i>(union)</i>
data SumPositiveIntegerOrEmpty

-- | //
SumPositiveIntegerOrEmpty :: SumPositiveIntegerOrEmpty
parseSumPositiveIntegerOrEmpty :: String -> XParse SumPositiveIntegerOrEmpty

-- | <tt>accidental</tt> <i>(complex)</i>
--   
--   The accidental type represents actual notated accidentals. Editorial
--   and cautionary indications are indicated by attributes. Values for
--   these attributes are "no" if not present. Specific graphic display
--   such as parentheses, brackets, and size are controlled by the
--   level-display attribute group.
data Accidental
Accidental :: AccidentalValue -> Maybe YesNo -> Maybe YesNo -> Maybe SmuflAccidentalGlyphName -> Maybe YesNo -> Maybe YesNo -> Maybe SymbolSize -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Accidental

-- | text content
[accidentalAccidentalValue] :: Accidental -> AccidentalValue

-- | <i>cautionary</i> attribute
[accidentalCautionary] :: Accidental -> Maybe YesNo

-- | <i>editorial</i> attribute
[accidentalEditorial] :: Accidental -> Maybe YesNo

-- | <i>smufl</i> attribute
[accidentalSmufl] :: Accidental -> Maybe SmuflAccidentalGlyphName

-- | <i>parentheses</i> attribute
[accidentalParentheses] :: Accidental -> Maybe YesNo

-- | <i>bracket</i> attribute
[accidentalBracket] :: Accidental -> Maybe YesNo

-- | <i>size</i> attribute
[accidentalSize] :: Accidental -> Maybe SymbolSize

-- | <i>default-x</i> attribute
[accidentalDefaultX] :: Accidental -> Maybe Tenths

-- | <i>default-y</i> attribute
[accidentalDefaultY] :: Accidental -> Maybe Tenths

-- | <i>relative-x</i> attribute
[accidentalRelativeX] :: Accidental -> Maybe Tenths

-- | <i>relative-y</i> attribute
[accidentalRelativeY] :: Accidental -> Maybe Tenths

-- | <i>font-family</i> attribute
[accidentalFontFamily] :: Accidental -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[accidentalFontStyle] :: Accidental -> Maybe FontStyle

-- | <i>font-size</i> attribute
[accidentalFontSize] :: Accidental -> Maybe FontSize

-- | <i>font-weight</i> attribute
[accidentalFontWeight] :: Accidental -> Maybe FontWeight

-- | <i>color</i> attribute
[accidentalColor] :: Accidental -> Maybe Color
parseAccidental :: XParse Accidental

-- | Smart constructor for <a>Accidental</a>
mkAccidental :: AccidentalValue -> Accidental

-- | <tt>accidental-mark</tt> <i>(complex)</i>
--   
--   An accidental-mark can be used as a separate notation or as part of an
--   ornament. When used in an ornament, position and placement are
--   relative to the ornament, not relative to the note.
data AccidentalMark
AccidentalMark :: AccidentalValue -> Maybe SmuflAccidentalGlyphName -> Maybe YesNo -> Maybe YesNo -> Maybe SymbolSize -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe ID -> AccidentalMark

-- | text content
[accidentalMarkAccidentalValue] :: AccidentalMark -> AccidentalValue

-- | <i>smufl</i> attribute
[accidentalMarkSmufl] :: AccidentalMark -> Maybe SmuflAccidentalGlyphName

-- | <i>parentheses</i> attribute
[accidentalMarkParentheses] :: AccidentalMark -> Maybe YesNo

-- | <i>bracket</i> attribute
[accidentalMarkBracket] :: AccidentalMark -> Maybe YesNo

-- | <i>size</i> attribute
[accidentalMarkSize] :: AccidentalMark -> Maybe SymbolSize

-- | <i>default-x</i> attribute
[accidentalMarkDefaultX] :: AccidentalMark -> Maybe Tenths

-- | <i>default-y</i> attribute
[accidentalMarkDefaultY] :: AccidentalMark -> Maybe Tenths

-- | <i>relative-x</i> attribute
[accidentalMarkRelativeX] :: AccidentalMark -> Maybe Tenths

-- | <i>relative-y</i> attribute
[accidentalMarkRelativeY] :: AccidentalMark -> Maybe Tenths

-- | <i>font-family</i> attribute
[accidentalMarkFontFamily] :: AccidentalMark -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[accidentalMarkFontStyle] :: AccidentalMark -> Maybe FontStyle

-- | <i>font-size</i> attribute
[accidentalMarkFontSize] :: AccidentalMark -> Maybe FontSize

-- | <i>font-weight</i> attribute
[accidentalMarkFontWeight] :: AccidentalMark -> Maybe FontWeight

-- | <i>color</i> attribute
[accidentalMarkColor] :: AccidentalMark -> Maybe Color

-- | <i>placement</i> attribute
[accidentalMarkPlacement] :: AccidentalMark -> Maybe AboveBelow

-- | <i>id</i> attribute
[accidentalMarkId] :: AccidentalMark -> Maybe ID
parseAccidentalMark :: XParse AccidentalMark

-- | Smart constructor for <a>AccidentalMark</a>
mkAccidentalMark :: AccidentalValue -> AccidentalMark

-- | <tt>accidental-text</tt> <i>(complex)</i>
--   
--   The accidental-text type represents an element with an accidental
--   value and text-formatting attributes.
data AccidentalText
AccidentalText :: AccidentalValue -> Maybe SmuflAccidentalGlyphName -> Maybe Lang -> Maybe Space -> Maybe LeftCenterRight -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe RotationDegrees -> Maybe NumberOrNormal -> Maybe NumberOrNormal -> Maybe TextDirection -> Maybe EnclosureShape -> AccidentalText

-- | text content
[accidentalTextAccidentalValue] :: AccidentalText -> AccidentalValue

-- | <i>smufl</i> attribute
[accidentalTextSmufl] :: AccidentalText -> Maybe SmuflAccidentalGlyphName

-- | <i>xml:lang</i> attribute
[accidentalTextLang] :: AccidentalText -> Maybe Lang

-- | <i>xml:space</i> attribute
[accidentalTextSpace] :: AccidentalText -> Maybe Space

-- | <i>justify</i> attribute
[accidentalTextJustify] :: AccidentalText -> Maybe LeftCenterRight

-- | <i>default-x</i> attribute
[accidentalTextDefaultX] :: AccidentalText -> Maybe Tenths

-- | <i>default-y</i> attribute
[accidentalTextDefaultY] :: AccidentalText -> Maybe Tenths

-- | <i>relative-x</i> attribute
[accidentalTextRelativeX] :: AccidentalText -> Maybe Tenths

-- | <i>relative-y</i> attribute
[accidentalTextRelativeY] :: AccidentalText -> Maybe Tenths

-- | <i>font-family</i> attribute
[accidentalTextFontFamily] :: AccidentalText -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[accidentalTextFontStyle] :: AccidentalText -> Maybe FontStyle

-- | <i>font-size</i> attribute
[accidentalTextFontSize] :: AccidentalText -> Maybe FontSize

-- | <i>font-weight</i> attribute
[accidentalTextFontWeight] :: AccidentalText -> Maybe FontWeight

-- | <i>color</i> attribute
[accidentalTextColor] :: AccidentalText -> Maybe Color

-- | <i>halign</i> attribute
[accidentalTextHalign] :: AccidentalText -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[accidentalTextValign] :: AccidentalText -> Maybe Valign

-- | <i>underline</i> attribute
[accidentalTextUnderline] :: AccidentalText -> Maybe NumberOfLines

-- | <i>overline</i> attribute
[accidentalTextOverline] :: AccidentalText -> Maybe NumberOfLines

-- | <i>line-through</i> attribute
[accidentalTextLineThrough] :: AccidentalText -> Maybe NumberOfLines

-- | <i>rotation</i> attribute
[accidentalTextRotation] :: AccidentalText -> Maybe RotationDegrees

-- | <i>letter-spacing</i> attribute
[accidentalTextLetterSpacing] :: AccidentalText -> Maybe NumberOrNormal

-- | <i>line-height</i> attribute
[accidentalTextLineHeight] :: AccidentalText -> Maybe NumberOrNormal

-- | <i>dir</i> attribute
[accidentalTextDir] :: AccidentalText -> Maybe TextDirection

-- | <i>enclosure</i> attribute
[accidentalTextEnclosure] :: AccidentalText -> Maybe EnclosureShape
parseAccidentalText :: XParse AccidentalText

-- | Smart constructor for <a>AccidentalText</a>
mkAccidentalText :: AccidentalValue -> AccidentalText

-- | <tt>accord</tt> <i>(complex)</i>
--   
--   The accord type represents the tuning of a single string in the
--   scordatura element. It uses the same group of elements as the
--   staff-tuning element. Strings are numbered from high to low.
data Accord
Accord :: Maybe StringNumber -> Tuning -> Accord

-- | <i>string</i> attribute
[accordString] :: Accord -> Maybe StringNumber
[accordTuning] :: Accord -> Tuning
parseAccord :: XParse Accord

-- | Smart constructor for <a>Accord</a>
mkAccord :: Tuning -> Accord

-- | <tt>accordion-registration</tt> <i>(complex)</i>
--   
--   The accordion-registration type is use for accordion registration
--   symbols. These are circular symbols divided horizontally into high,
--   middle, and low sections that correspond to 4', 8', and 16' pipes.
--   Each accordion-high, accordion-middle, and accordion-low element
--   represents the presence of one or more dots in the registration
--   diagram. An accordion-registration element needs to have at least one
--   of the child elements present.
data AccordionRegistration
AccordionRegistration :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> Maybe Empty -> Maybe AccordionMiddle -> Maybe Empty -> AccordionRegistration

-- | <i>default-x</i> attribute
[accordionRegistrationDefaultX] :: AccordionRegistration -> Maybe Tenths

-- | <i>default-y</i> attribute
[accordionRegistrationDefaultY] :: AccordionRegistration -> Maybe Tenths

-- | <i>relative-x</i> attribute
[accordionRegistrationRelativeX] :: AccordionRegistration -> Maybe Tenths

-- | <i>relative-y</i> attribute
[accordionRegistrationRelativeY] :: AccordionRegistration -> Maybe Tenths

-- | <i>font-family</i> attribute
[accordionRegistrationFontFamily] :: AccordionRegistration -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[accordionRegistrationFontStyle] :: AccordionRegistration -> Maybe FontStyle

-- | <i>font-size</i> attribute
[accordionRegistrationFontSize] :: AccordionRegistration -> Maybe FontSize

-- | <i>font-weight</i> attribute
[accordionRegistrationFontWeight] :: AccordionRegistration -> Maybe FontWeight

-- | <i>color</i> attribute
[accordionRegistrationColor] :: AccordionRegistration -> Maybe Color

-- | <i>halign</i> attribute
[accordionRegistrationHalign] :: AccordionRegistration -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[accordionRegistrationValign] :: AccordionRegistration -> Maybe Valign

-- | <i>id</i> attribute
[accordionRegistrationId] :: AccordionRegistration -> Maybe ID

-- | <i>accordion-high</i> child element
[accordionRegistrationAccordionHigh] :: AccordionRegistration -> Maybe Empty

-- | <i>accordion-middle</i> child element
[accordionRegistrationAccordionMiddle] :: AccordionRegistration -> Maybe AccordionMiddle

-- | <i>accordion-low</i> child element
[accordionRegistrationAccordionLow] :: AccordionRegistration -> Maybe Empty
parseAccordionRegistration :: XParse AccordionRegistration

-- | Smart constructor for <a>AccordionRegistration</a>
mkAccordionRegistration :: AccordionRegistration

-- | <tt>appearance</tt> <i>(complex)</i>
--   
--   The appearance type controls general graphical settings for the
--   music's final form appearance on a printed page of display. This
--   includes support for line widths, definitions for note sizes, and
--   standard distances between notation elements, plus an extension
--   element for other aspects of appearance.
data Appearance
Appearance :: [LineWidth] -> [NoteSize] -> [Distance] -> [Glyph] -> [OtherAppearance] -> Appearance

-- | <i>line-width</i> child element
[appearanceLineWidth] :: Appearance -> [LineWidth]

-- | <i>note-size</i> child element
[appearanceNoteSize] :: Appearance -> [NoteSize]

-- | <i>distance</i> child element
[appearanceDistance] :: Appearance -> [Distance]

-- | <i>glyph</i> child element
[appearanceGlyph] :: Appearance -> [Glyph]

-- | <i>other-appearance</i> child element
[appearanceOtherAppearance] :: Appearance -> [OtherAppearance]
parseAppearance :: XParse Appearance

-- | Smart constructor for <a>Appearance</a>
mkAppearance :: Appearance

-- | <tt>arpeggiate</tt> <i>(complex)</i>
--   
--   The arpeggiate type indicates that this note is part of an arpeggiated
--   chord. The number attribute can be used to distinguish between two
--   simultaneous chords arpeggiated separately (different numbers) or
--   together (same number). The up-down attribute is used if there is an
--   arrow on the arpeggio sign. By default, arpeggios go from the lowest
--   to highest note.
data Arpeggiate
Arpeggiate :: Maybe NumberLevel -> Maybe UpDown -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe AboveBelow -> Maybe Color -> Maybe ID -> Arpeggiate

-- | <i>number</i> attribute
[arpeggiateNumber] :: Arpeggiate -> Maybe NumberLevel

-- | <i>direction</i> attribute
[arpeggiateDirection] :: Arpeggiate -> Maybe UpDown

-- | <i>default-x</i> attribute
[arpeggiateDefaultX] :: Arpeggiate -> Maybe Tenths

-- | <i>default-y</i> attribute
[arpeggiateDefaultY] :: Arpeggiate -> Maybe Tenths

-- | <i>relative-x</i> attribute
[arpeggiateRelativeX] :: Arpeggiate -> Maybe Tenths

-- | <i>relative-y</i> attribute
[arpeggiateRelativeY] :: Arpeggiate -> Maybe Tenths

-- | <i>placement</i> attribute
[arpeggiatePlacement] :: Arpeggiate -> Maybe AboveBelow

-- | <i>color</i> attribute
[arpeggiateColor] :: Arpeggiate -> Maybe Color

-- | <i>id</i> attribute
[arpeggiateId] :: Arpeggiate -> Maybe ID
parseArpeggiate :: XParse Arpeggiate

-- | Smart constructor for <a>Arpeggiate</a>
mkArpeggiate :: Arpeggiate

-- | <tt>arrow</tt> <i>(complex)</i>
--   
--   The arrow element represents an arrow used for a musical technical
--   indication. It can represent both Unicode and SMuFL arrows. The
--   presence of an arrowhead element indicates that only the arrowhead is
--   displayed, not the arrow stem. The smufl attribute distinguishes
--   different SMuFL glyphs that have an arrow appearance such as
--   arrowBlackUp, guitarStrumUp, or handbellsSwingUp. The specified glyph
--   should match the descriptive representation.
data Arrow
Arrow :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe SmuflGlyphName -> ChxArrow -> Arrow

-- | <i>default-x</i> attribute
[arrowDefaultX] :: Arrow -> Maybe Tenths

-- | <i>default-y</i> attribute
[arrowDefaultY] :: Arrow -> Maybe Tenths

-- | <i>relative-x</i> attribute
[arrowRelativeX] :: Arrow -> Maybe Tenths

-- | <i>relative-y</i> attribute
[arrowRelativeY] :: Arrow -> Maybe Tenths

-- | <i>font-family</i> attribute
[arrowFontFamily] :: Arrow -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[arrowFontStyle] :: Arrow -> Maybe FontStyle

-- | <i>font-size</i> attribute
[arrowFontSize] :: Arrow -> Maybe FontSize

-- | <i>font-weight</i> attribute
[arrowFontWeight] :: Arrow -> Maybe FontWeight

-- | <i>color</i> attribute
[arrowColor] :: Arrow -> Maybe Color

-- | <i>placement</i> attribute
[arrowPlacement] :: Arrow -> Maybe AboveBelow

-- | <i>smufl</i> attribute
[arrowSmufl] :: Arrow -> Maybe SmuflGlyphName
[arrowArrow] :: Arrow -> ChxArrow
parseArrow :: XParse Arrow

-- | Smart constructor for <a>Arrow</a>
mkArrow :: ChxArrow -> Arrow

-- | <tt>articulations</tt> <i>(complex)</i>
--   
--   Articulations and accents are grouped together here.
data Articulations
Articulations :: Maybe ID -> [ChxArticulations] -> Articulations

-- | <i>id</i> attribute
[articulationsId] :: Articulations -> Maybe ID
[articulationsArticulations] :: Articulations -> [ChxArticulations]
parseArticulations :: XParse Articulations

-- | Smart constructor for <a>Articulations</a>
mkArticulations :: Articulations

-- | <tt>attributes</tt> <i>(complex)</i>
--   
--   The attributes element contains musical information that typically
--   changes on measure boundaries. This includes key and time signatures,
--   clefs, transpositions, and staving. When attributes are changed
--   mid-measure, it affects the music in score order, not in MusicXML
--   document order.
data Attributes
Attributes :: Editorial -> Maybe PositiveDivisions -> [Key] -> [Time] -> Maybe NonNegativeInteger -> Maybe PartSymbol -> Maybe NonNegativeInteger -> [Clef] -> [StaffDetails] -> [Transpose] -> [Directive] -> [MeasureStyle] -> Attributes
[attributesEditorial] :: Attributes -> Editorial

-- | <i>divisions</i> child element
[attributesDivisions] :: Attributes -> Maybe PositiveDivisions

-- | <i>key</i> child element
[attributesKey] :: Attributes -> [Key]

-- | <i>time</i> child element
[attributesTime] :: Attributes -> [Time]

-- | <i>staves</i> child element
[attributesStaves] :: Attributes -> Maybe NonNegativeInteger

-- | <i>part-symbol</i> child element
[attributesPartSymbol] :: Attributes -> Maybe PartSymbol

-- | <i>instruments</i> child element
[attributesInstruments] :: Attributes -> Maybe NonNegativeInteger

-- | <i>clef</i> child element
[attributesClef] :: Attributes -> [Clef]

-- | <i>staff-details</i> child element
[attributesStaffDetails] :: Attributes -> [StaffDetails]

-- | <i>transpose</i> child element
[attributesTranspose] :: Attributes -> [Transpose]

-- | <i>directive</i> child element
[attributesDirective] :: Attributes -> [Directive]

-- | <i>measure-style</i> child element
[attributesMeasureStyle] :: Attributes -> [MeasureStyle]
parseAttributes :: XParse Attributes

-- | Smart constructor for <a>Attributes</a>
mkAttributes :: Editorial -> Attributes

-- | <tt>backup</tt> <i>(complex)</i>
--   
--   The backup and forward elements are required to coordinate multiple
--   voices in one part, including music on multiple staves. The backup
--   type is generally used to move between voices and staves. Thus the
--   backup element does not include voice or staff elements. Duration
--   values should always be positive, and should not cross measure
--   boundaries or mid-measure changes in the divisions value.
data Backup
Backup :: Duration -> Editorial -> Backup
[backupDuration] :: Backup -> Duration
[backupEditorial] :: Backup -> Editorial
parseBackup :: XParse Backup

-- | Smart constructor for <a>Backup</a>
mkBackup :: Duration -> Editorial -> Backup

-- | <tt>bar-style-color</tt> <i>(complex)</i>
--   
--   The bar-style-color type contains barline style and color information.
data BarStyleColor
BarStyleColor :: BarStyle -> Maybe Color -> BarStyleColor

-- | text content
[barStyleColorBarStyle] :: BarStyleColor -> BarStyle

-- | <i>color</i> attribute
[barStyleColorColor] :: BarStyleColor -> Maybe Color
parseBarStyleColor :: XParse BarStyleColor

-- | Smart constructor for <a>BarStyleColor</a>
mkBarStyleColor :: BarStyle -> BarStyleColor

-- | <tt>barline</tt> <i>(complex)</i>
--   
--   If a barline is other than a normal single barline, it should be
--   represented by a barline type that describes it. This includes
--   information about repeats and multiple endings, as well as line style.
--   Barline data is on the same level as the other musical data in a score
--   - a child of a measure in a partwise score, or a part in a timewise
--   score. This allows for barlines within measures, as in dotted barlines
--   that subdivide measures in complex meters. The two fermata elements
--   allow for fermatas on both sides of the barline (the lower one
--   inverted).
--   
--   Barlines have a location attribute to make it easier to process
--   barlines independently of the other musical data in a score. It is
--   often easier to set up measures separately from entering notes. The
--   location attribute must match where the barline element occurs within
--   the rest of the musical data in the score. If location is left, it
--   should be the first element in the measure, aside from the print,
--   bookmark, and link elements. If location is right, it should be the
--   last element, again with the possible exception of the print,
--   bookmark, and link elements. If no location is specified, the right
--   barline is the default. The segno, coda, and divisions attributes work
--   the same way as in the sound element. They are used for playback when
--   barline elements contain segno or coda child elements.
data Barline
Barline :: Maybe RightLeftMiddle -> Maybe Token -> Maybe Token -> Maybe Divisions -> Maybe ID -> Maybe BarStyleColor -> Editorial -> Maybe WavyLine -> Maybe Segno -> Maybe Coda -> [Fermata] -> Maybe Ending -> Maybe Repeat -> Barline

-- | <i>location</i> attribute
[barlineLocation] :: Barline -> Maybe RightLeftMiddle

-- | <i>segno</i> attribute
[barlineSegno] :: Barline -> Maybe Token

-- | <i>coda</i> attribute
[barlineCoda] :: Barline -> Maybe Token

-- | <i>divisions</i> attribute
[barlineDivisions] :: Barline -> Maybe Divisions

-- | <i>id</i> attribute
[barlineId] :: Barline -> Maybe ID

-- | <i>bar-style</i> child element
[barlineBarStyle] :: Barline -> Maybe BarStyleColor
[barlineEditorial] :: Barline -> Editorial

-- | <i>wavy-line</i> child element
[barlineWavyLine] :: Barline -> Maybe WavyLine

-- | <i>segno</i> child element
[barlineSegno1] :: Barline -> Maybe Segno

-- | <i>coda</i> child element
[barlineCoda1] :: Barline -> Maybe Coda

-- | <i>fermata</i> child element
[barlineFermata] :: Barline -> [Fermata]

-- | <i>ending</i> child element
[barlineEnding] :: Barline -> Maybe Ending

-- | <i>repeat</i> child element
[barlineRepeat] :: Barline -> Maybe Repeat
parseBarline :: XParse Barline

-- | Smart constructor for <a>Barline</a>
mkBarline :: Editorial -> Barline

-- | <tt>barre</tt> <i>(complex)</i>
--   
--   The barre element indicates placing a finger over multiple strings on
--   a single fret. The type is "start" for the lowest pitched string
--   (e.g., the string with the highest MusicXML number) and is "stop" for
--   the highest pitched string.
data Barre
Barre :: StartStop -> Maybe Color -> Barre

-- | <i>type</i> attribute
[barreType] :: Barre -> StartStop

-- | <i>color</i> attribute
[barreColor] :: Barre -> Maybe Color
parseBarre :: XParse Barre

-- | Smart constructor for <a>Barre</a>
mkBarre :: StartStop -> Barre

-- | <tt>bass</tt> <i>(complex)</i>
--   
--   The bass type is used to indicate a bass note in popular music chord
--   symbols, e.g. G/C. It is generally not used in functional harmony, as
--   inversion is generally not used in pop chord symbols. As with root, it
--   is divided into step and alter elements, similar to pitches.
data Bass
Bass :: BassStep -> Maybe BassAlter -> Bass

-- | <i>bass-step</i> child element
[bassBassStep] :: Bass -> BassStep

-- | <i>bass-alter</i> child element
[bassBassAlter] :: Bass -> Maybe BassAlter
parseBass :: XParse Bass

-- | Smart constructor for <a>Bass</a>
mkBass :: BassStep -> Bass

-- | <tt>bass-alter</tt> <i>(complex)</i>
--   
--   The bass-alter type represents the chromatic alteration of the bass of
--   the current chord within the harmony element. In some chord styles,
--   the text for the bass-step element may include bass-alter information.
--   In that case, the print-object attribute of the bass-alter element can
--   be set to no. The location attribute indicates whether the alteration
--   should appear to the left or the right of the bass-step; it is right
--   by default.
data BassAlter
BassAlter :: Semitones -> Maybe LeftRight -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> BassAlter

-- | text content
[bassAlterSemitones] :: BassAlter -> Semitones

-- | <i>location</i> attribute
[bassAlterLocation] :: BassAlter -> Maybe LeftRight

-- | <i>print-object</i> attribute
[bassAlterPrintObject] :: BassAlter -> Maybe YesNo

-- | <i>default-x</i> attribute
[bassAlterDefaultX] :: BassAlter -> Maybe Tenths

-- | <i>default-y</i> attribute
[bassAlterDefaultY] :: BassAlter -> Maybe Tenths

-- | <i>relative-x</i> attribute
[bassAlterRelativeX] :: BassAlter -> Maybe Tenths

-- | <i>relative-y</i> attribute
[bassAlterRelativeY] :: BassAlter -> Maybe Tenths

-- | <i>font-family</i> attribute
[bassAlterFontFamily] :: BassAlter -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[bassAlterFontStyle] :: BassAlter -> Maybe FontStyle

-- | <i>font-size</i> attribute
[bassAlterFontSize] :: BassAlter -> Maybe FontSize

-- | <i>font-weight</i> attribute
[bassAlterFontWeight] :: BassAlter -> Maybe FontWeight

-- | <i>color</i> attribute
[bassAlterColor] :: BassAlter -> Maybe Color
parseBassAlter :: XParse BassAlter

-- | Smart constructor for <a>BassAlter</a>
mkBassAlter :: Semitones -> BassAlter

-- | <tt>bass-step</tt> <i>(complex)</i>
--   
--   The bass-step type represents the pitch step of the bass of the
--   current chord within the harmony element. The text attribute indicates
--   how the bass should appear in a score if not using the element
--   contents.
data BassStep
BassStep :: Step -> Maybe Token -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> BassStep

-- | text content
[bassStepStep] :: BassStep -> Step

-- | <i>text</i> attribute
[bassStepText] :: BassStep -> Maybe Token

-- | <i>default-x</i> attribute
[bassStepDefaultX] :: BassStep -> Maybe Tenths

-- | <i>default-y</i> attribute
[bassStepDefaultY] :: BassStep -> Maybe Tenths

-- | <i>relative-x</i> attribute
[bassStepRelativeX] :: BassStep -> Maybe Tenths

-- | <i>relative-y</i> attribute
[bassStepRelativeY] :: BassStep -> Maybe Tenths

-- | <i>font-family</i> attribute
[bassStepFontFamily] :: BassStep -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[bassStepFontStyle] :: BassStep -> Maybe FontStyle

-- | <i>font-size</i> attribute
[bassStepFontSize] :: BassStep -> Maybe FontSize

-- | <i>font-weight</i> attribute
[bassStepFontWeight] :: BassStep -> Maybe FontWeight

-- | <i>color</i> attribute
[bassStepColor] :: BassStep -> Maybe Color
parseBassStep :: XParse BassStep

-- | Smart constructor for <a>BassStep</a>
mkBassStep :: Step -> BassStep

-- | <tt>beam</tt> <i>(complex)</i>
--   
--   Beam values include begin, continue, end, forward hook, and backward
--   hook. Up to eight concurrent beams are available to cover up to 1024th
--   notes. Each beam in a note is represented with a separate beam
--   element, starting with the eighth note beam using a number attribute
--   of 1.
--   
--   Note that the beam number does not distinguish sets of beams that
--   overlap, as it does for slur and other elements. Beaming groups are
--   distinguished by being in different voices and/or the presence or
--   absence of grace and cue elements.
--   
--   Beams that have a begin value can also have a fan attribute to
--   indicate accelerandos and ritardandos using fanned beams. The fan
--   attribute may also be used with a continue value if the fanning
--   direction changes on that note. The value is "none" if not specified.
--   
--   The repeater attribute has been deprecated in MusicXML 3.0. Formerly
--   used for tremolos, it needs to be specified with a "yes" value for
--   each beam using it.
data Beam
Beam :: BeamValue -> Maybe BeamLevel -> Maybe YesNo -> Maybe Fan -> Maybe Color -> Maybe ID -> Beam

-- | text content
[beamBeamValue] :: Beam -> BeamValue

-- | <i>number</i> attribute
[beamNumber] :: Beam -> Maybe BeamLevel

-- | <i>repeater</i> attribute
[beamRepeater] :: Beam -> Maybe YesNo

-- | <i>fan</i> attribute
[beamFan] :: Beam -> Maybe Fan

-- | <i>color</i> attribute
[beamColor] :: Beam -> Maybe Color

-- | <i>id</i> attribute
[beamId] :: Beam -> Maybe ID
parseBeam :: XParse Beam

-- | Smart constructor for <a>Beam</a>
mkBeam :: BeamValue -> Beam

-- | <tt>beat-repeat</tt> <i>(complex)</i>
--   
--   The beat-repeat type is used to indicate that a single beat (but
--   possibly many notes) is repeated. Both the start and stop of the beat
--   being repeated should be specified. The slashes attribute specifies
--   the number of slashes to use in the symbol. The use-dots attribute
--   indicates whether or not to use dots as well (for instance, with mixed
--   rhythm patterns). By default, the value for slashes is 1 and the value
--   for use-dots is no.
--   
--   The beat-repeat element specifies a notation style for repetitions.
--   The actual music being repeated needs to be repeated within the
--   MusicXML file. This element specifies the notation that indicates the
--   repeat.
data BeatRepeat
BeatRepeat :: StartStop -> Maybe PositiveInteger -> Maybe YesNo -> Maybe Slash -> BeatRepeat

-- | <i>type</i> attribute
[beatRepeatType] :: BeatRepeat -> StartStop

-- | <i>slashes</i> attribute
[beatRepeatSlashes] :: BeatRepeat -> Maybe PositiveInteger

-- | <i>use-dots</i> attribute
[beatRepeatUseDots] :: BeatRepeat -> Maybe YesNo
[beatRepeatSlash] :: BeatRepeat -> Maybe Slash
parseBeatRepeat :: XParse BeatRepeat

-- | Smart constructor for <a>BeatRepeat</a>
mkBeatRepeat :: StartStop -> BeatRepeat

-- | <tt>beat-unit-tied</tt> <i>(complex)</i>
--   
--   The beat-unit-tied type indicates a beat-unit within a metronome mark
--   that is tied to the preceding beat-unit. This allows or two or more
--   tied notes to be associated with a per-minute value in a metronome
--   mark, whereas the metronome-tied element is restricted to metric
--   relationship marks.
data BeatUnitTied
BeatUnitTied :: BeatUnit -> BeatUnitTied
[beatUnitTiedBeatUnit] :: BeatUnitTied -> BeatUnit
parseBeatUnitTied :: XParse BeatUnitTied

-- | Smart constructor for <a>BeatUnitTied</a>
mkBeatUnitTied :: BeatUnit -> BeatUnitTied

-- | <tt>beater</tt> <i>(complex)</i>
--   
--   The beater type represents pictograms for beaters, mallets, and sticks
--   that do not have different materials represented in the pictogram.
data Beater
Beater :: BeaterValue -> Maybe TipDirection -> Beater

-- | text content
[beaterBeaterValue] :: Beater -> BeaterValue

-- | <i>tip</i> attribute
[beaterTip] :: Beater -> Maybe TipDirection
parseBeater :: XParse Beater

-- | Smart constructor for <a>Beater</a>
mkBeater :: BeaterValue -> Beater

-- | <tt>bend</tt> <i>(complex)</i>
--   
--   The bend type is used in guitar and tablature. The bend-alter element
--   indicates the number of steps in the bend, similar to the alter
--   element. As with the alter element, numbers like 0.5 can be used to
--   indicate microtones. Negative numbers indicate pre-bends or releases;
--   the pre-bend and release elements are used to distinguish what is
--   intended. A with-bar element indicates that the bend is to be done at
--   the bridge with a whammy or vibrato bar. The content of the element
--   indicates how this should be notated.
data Bend
Bend :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe YesNo -> Maybe TrillBeats -> Maybe Percent -> Maybe Percent -> Semitones -> Maybe ChxBend -> Maybe PlacementText -> Bend

-- | <i>default-x</i> attribute
[bendDefaultX] :: Bend -> Maybe Tenths

-- | <i>default-y</i> attribute
[bendDefaultY] :: Bend -> Maybe Tenths

-- | <i>relative-x</i> attribute
[bendRelativeX] :: Bend -> Maybe Tenths

-- | <i>relative-y</i> attribute
[bendRelativeY] :: Bend -> Maybe Tenths

-- | <i>font-family</i> attribute
[bendFontFamily] :: Bend -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[bendFontStyle] :: Bend -> Maybe FontStyle

-- | <i>font-size</i> attribute
[bendFontSize] :: Bend -> Maybe FontSize

-- | <i>font-weight</i> attribute
[bendFontWeight] :: Bend -> Maybe FontWeight

-- | <i>color</i> attribute
[bendColor] :: Bend -> Maybe Color

-- | <i>accelerate</i> attribute
[bendAccelerate] :: Bend -> Maybe YesNo

-- | <i>beats</i> attribute
[bendBeats] :: Bend -> Maybe TrillBeats

-- | <i>first-beat</i> attribute
[bendFirstBeat] :: Bend -> Maybe Percent

-- | <i>last-beat</i> attribute
[bendLastBeat] :: Bend -> Maybe Percent

-- | <i>bend-alter</i> child element
[bendBendAlter] :: Bend -> Semitones
[bendBend] :: Bend -> Maybe ChxBend

-- | <i>with-bar</i> child element
[bendWithBar] :: Bend -> Maybe PlacementText
parseBend :: XParse Bend

-- | Smart constructor for <a>Bend</a>
mkBend :: Semitones -> Bend

-- | <tt>bookmark</tt> <i>(complex)</i>
--   
--   The bookmark type serves as a well-defined target for an incoming
--   simple XLink.
data Bookmark
Bookmark :: ID -> Maybe Token -> Maybe NMTOKEN -> Maybe PositiveInteger -> Bookmark

-- | <i>id</i> attribute
[bookmarkId] :: Bookmark -> ID

-- | <i>name</i> attribute
[bookmarkName] :: Bookmark -> Maybe Token

-- | <i>element</i> attribute
[bookmarkElement] :: Bookmark -> Maybe NMTOKEN

-- | <i>position</i> attribute
[bookmarkPosition] :: Bookmark -> Maybe PositiveInteger
parseBookmark :: XParse Bookmark

-- | Smart constructor for <a>Bookmark</a>
mkBookmark :: ID -> Bookmark

-- | <tt>bracket</tt> <i>(complex)</i>
--   
--   Brackets are combined with words in a variety of modern directions.
--   The line-end attribute specifies if there is a jog up or down (or
--   both), an arrow, or nothing at the start or end of the bracket. If the
--   line-end is up or down, the length of the jog can be specified using
--   the end-length attribute. The line-type is solid by default.
data Bracket
Bracket :: StartStopContinue -> Maybe NumberLevel -> LineEnd -> Maybe Tenths -> Maybe LineType -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Color -> Maybe ID -> Bracket

-- | <i>type</i> attribute
[bracketType] :: Bracket -> StartStopContinue

-- | <i>number</i> attribute
[bracketNumber] :: Bracket -> Maybe NumberLevel

-- | <i>line-end</i> attribute
[bracketLineEnd] :: Bracket -> LineEnd

-- | <i>end-length</i> attribute
[bracketEndLength] :: Bracket -> Maybe Tenths

-- | <i>line-type</i> attribute
[bracketLineType] :: Bracket -> Maybe LineType

-- | <i>dash-length</i> attribute
[bracketDashLength] :: Bracket -> Maybe Tenths

-- | <i>space-length</i> attribute
[bracketSpaceLength] :: Bracket -> Maybe Tenths

-- | <i>default-x</i> attribute
[bracketDefaultX] :: Bracket -> Maybe Tenths

-- | <i>default-y</i> attribute
[bracketDefaultY] :: Bracket -> Maybe Tenths

-- | <i>relative-x</i> attribute
[bracketRelativeX] :: Bracket -> Maybe Tenths

-- | <i>relative-y</i> attribute
[bracketRelativeY] :: Bracket -> Maybe Tenths

-- | <i>color</i> attribute
[bracketColor] :: Bracket -> Maybe Color

-- | <i>id</i> attribute
[bracketId] :: Bracket -> Maybe ID
parseBracket :: XParse Bracket

-- | Smart constructor for <a>Bracket</a>
mkBracket :: StartStopContinue -> LineEnd -> Bracket

-- | <tt>breath-mark</tt> <i>(complex)</i>
--   
--   The breath-mark element indicates a place to take a breath.
data BreathMark
BreathMark :: BreathMarkValue -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> BreathMark

-- | text content
[breathMarkBreathMarkValue] :: BreathMark -> BreathMarkValue

-- | <i>default-x</i> attribute
[breathMarkDefaultX] :: BreathMark -> Maybe Tenths

-- | <i>default-y</i> attribute
[breathMarkDefaultY] :: BreathMark -> Maybe Tenths

-- | <i>relative-x</i> attribute
[breathMarkRelativeX] :: BreathMark -> Maybe Tenths

-- | <i>relative-y</i> attribute
[breathMarkRelativeY] :: BreathMark -> Maybe Tenths

-- | <i>font-family</i> attribute
[breathMarkFontFamily] :: BreathMark -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[breathMarkFontStyle] :: BreathMark -> Maybe FontStyle

-- | <i>font-size</i> attribute
[breathMarkFontSize] :: BreathMark -> Maybe FontSize

-- | <i>font-weight</i> attribute
[breathMarkFontWeight] :: BreathMark -> Maybe FontWeight

-- | <i>color</i> attribute
[breathMarkColor] :: BreathMark -> Maybe Color

-- | <i>placement</i> attribute
[breathMarkPlacement] :: BreathMark -> Maybe AboveBelow
parseBreathMark :: XParse BreathMark

-- | Smart constructor for <a>BreathMark</a>
mkBreathMark :: BreathMarkValue -> BreathMark

-- | <tt>caesura</tt> <i>(complex)</i>
--   
--   The caesura element indicates a slight pause. It is notated using a
--   "railroad tracks" symbol or other variations specified in the element
--   content.
data Caesura
Caesura :: CaesuraValue -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Caesura

-- | text content
[caesuraCaesuraValue] :: Caesura -> CaesuraValue

-- | <i>default-x</i> attribute
[caesuraDefaultX] :: Caesura -> Maybe Tenths

-- | <i>default-y</i> attribute
[caesuraDefaultY] :: Caesura -> Maybe Tenths

-- | <i>relative-x</i> attribute
[caesuraRelativeX] :: Caesura -> Maybe Tenths

-- | <i>relative-y</i> attribute
[caesuraRelativeY] :: Caesura -> Maybe Tenths

-- | <i>font-family</i> attribute
[caesuraFontFamily] :: Caesura -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[caesuraFontStyle] :: Caesura -> Maybe FontStyle

-- | <i>font-size</i> attribute
[caesuraFontSize] :: Caesura -> Maybe FontSize

-- | <i>font-weight</i> attribute
[caesuraFontWeight] :: Caesura -> Maybe FontWeight

-- | <i>color</i> attribute
[caesuraColor] :: Caesura -> Maybe Color

-- | <i>placement</i> attribute
[caesuraPlacement] :: Caesura -> Maybe AboveBelow
parseCaesura :: XParse Caesura

-- | Smart constructor for <a>Caesura</a>
mkCaesura :: CaesuraValue -> Caesura

-- | <tt>cancel</tt> <i>(complex)</i>
--   
--   A cancel element indicates that the old key signature should be
--   cancelled before the new one appears. This will always happen when
--   changing to C major or A minor and need not be specified then. The
--   cancel value matches the fifths value of the cancelled key signature
--   (e.g., a cancel of -2 will provide an explicit cancellation for
--   changing from B flat major to F major). The optional location
--   attribute indicates where the cancellation appears relative to the new
--   key signature.
data Cancel
Cancel :: Fifths -> Maybe CancelLocation -> Cancel

-- | text content
[cancelFifths] :: Cancel -> Fifths

-- | <i>location</i> attribute
[cancelLocation] :: Cancel -> Maybe CancelLocation
parseCancel :: XParse Cancel

-- | Smart constructor for <a>Cancel</a>
mkCancel :: Fifths -> Cancel

-- | <tt>clef</tt> <i>(complex)</i>
--   
--   Clefs are represented by a combination of sign, line, and
--   clef-octave-change elements. The optional number attribute refers to
--   staff numbers within the part. A value of 1 is assumed if not present.
--   
--   Sometimes clefs are added to the staff in non-standard line positions,
--   either to indicate cue passages, or when there are multiple clefs
--   present simultaneously on one staff. In this situation, the additional
--   attribute is set to "yes" and the line value is ignored. The size
--   attribute is used for clefs where the additional attribute is "yes".
--   It is typically used to indicate cue clefs.
--   
--   Sometimes clefs at the start of a measure need to appear after the
--   barline rather than before, as for cues or for use after a repeated
--   section. The after-barline attribute is set to "yes" in this
--   situation. The attribute is ignored for mid-measure clefs.
--   
--   Clefs appear at the start of each system unless the print-object
--   attribute has been set to "no" or the additional attribute has been
--   set to "yes".
data Clef
Clef :: Maybe StaffNumber -> Maybe YesNo -> Maybe SymbolSize -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe YesNo -> Maybe ID -> ClefSign -> Maybe StaffLine -> Maybe Int -> Clef

-- | <i>number</i> attribute
[clefNumber] :: Clef -> Maybe StaffNumber

-- | <i>additional</i> attribute
[clefAdditional] :: Clef -> Maybe YesNo

-- | <i>size</i> attribute
[clefSize] :: Clef -> Maybe SymbolSize

-- | <i>after-barline</i> attribute
[clefAfterBarline] :: Clef -> Maybe YesNo

-- | <i>default-x</i> attribute
[clefDefaultX] :: Clef -> Maybe Tenths

-- | <i>default-y</i> attribute
[clefDefaultY] :: Clef -> Maybe Tenths

-- | <i>relative-x</i> attribute
[clefRelativeX] :: Clef -> Maybe Tenths

-- | <i>relative-y</i> attribute
[clefRelativeY] :: Clef -> Maybe Tenths

-- | <i>font-family</i> attribute
[clefFontFamily] :: Clef -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[clefFontStyle] :: Clef -> Maybe FontStyle

-- | <i>font-size</i> attribute
[clefFontSize] :: Clef -> Maybe FontSize

-- | <i>font-weight</i> attribute
[clefFontWeight] :: Clef -> Maybe FontWeight

-- | <i>color</i> attribute
[clefColor] :: Clef -> Maybe Color

-- | <i>print-object</i> attribute
[clefPrintObject] :: Clef -> Maybe YesNo

-- | <i>id</i> attribute
[clefId] :: Clef -> Maybe ID

-- | <i>sign</i> child element
[clefSign] :: Clef -> ClefSign

-- | <i>line</i> child element
[clefLine] :: Clef -> Maybe StaffLine

-- | <i>clef-octave-change</i> child element
[clefClefOctaveChange] :: Clef -> Maybe Int
parseClef :: XParse Clef

-- | Smart constructor for <a>Clef</a>
mkClef :: ClefSign -> Clef

-- | <tt>coda</tt> <i>(complex)</i>
--   
--   The coda type is the visual indicator of a coda sign. The exact glyph
--   can be specified with the smufl attribute. A sound element is also
--   needed to guide playback applications reliably.
data Coda
Coda :: Maybe SmuflCodaGlyphName -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> Coda

-- | <i>smufl</i> attribute
[codaSmufl] :: Coda -> Maybe SmuflCodaGlyphName

-- | <i>default-x</i> attribute
[codaDefaultX] :: Coda -> Maybe Tenths

-- | <i>default-y</i> attribute
[codaDefaultY] :: Coda -> Maybe Tenths

-- | <i>relative-x</i> attribute
[codaRelativeX] :: Coda -> Maybe Tenths

-- | <i>relative-y</i> attribute
[codaRelativeY] :: Coda -> Maybe Tenths

-- | <i>font-family</i> attribute
[codaFontFamily] :: Coda -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[codaFontStyle] :: Coda -> Maybe FontStyle

-- | <i>font-size</i> attribute
[codaFontSize] :: Coda -> Maybe FontSize

-- | <i>font-weight</i> attribute
[codaFontWeight] :: Coda -> Maybe FontWeight

-- | <i>color</i> attribute
[codaColor] :: Coda -> Maybe Color

-- | <i>halign</i> attribute
[codaHalign] :: Coda -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[codaValign] :: Coda -> Maybe Valign

-- | <i>id</i> attribute
[codaId] :: Coda -> Maybe ID
parseCoda :: XParse Coda

-- | Smart constructor for <a>Coda</a>
mkCoda :: Coda

-- | <tt>credit</tt> <i>(complex)</i>
--   
--   The credit type represents the appearance of the title, composer,
--   arranger, lyricist, copyright, dedication, and other text, symbols,
--   and graphics that commonly appear on the first page of a score. The
--   credit-words, credit-symbol, and credit-image elements are similar to
--   the words, symbol, and image elements for directions. However, since
--   the credit is not part of a measure, the default-x and default-y
--   attributes adjust the origin relative to the bottom left-hand corner
--   of the page. The enclosure for credit-words and credit-symbol is none
--   by default.
--   
--   By default, a series of credit-words and credit-symbol elements within
--   a single credit element follow one another in sequence visually.
--   Non-positional formatting attributes are carried over from the
--   previous element by default.
--   
--   The page attribute for the credit element specifies the page number
--   where the credit should appear. This is an integer value that starts
--   with 1 for the first page. Its value is 1 by default. Since credits
--   occur before the music, these page numbers do not refer to the page
--   numbering specified by the print element's page-number attribute.
--   
--   The credit-type element indicates the purpose behind a credit.
--   Multiple types of data may be combined in a single credit, so multiple
--   elements may be used. Standard values include page number, title,
--   subtitle, composer, arranger, lyricist, and rights.
data Credit
Credit :: Maybe PositiveInteger -> Maybe ID -> [String] -> [Link] -> [Bookmark] -> ChxCredit -> Credit

-- | <i>page</i> attribute
[creditPage] :: Credit -> Maybe PositiveInteger

-- | <i>id</i> attribute
[creditId] :: Credit -> Maybe ID

-- | <i>credit-type</i> child element
[creditCreditType] :: Credit -> [String]

-- | <i>link</i> child element
[creditLink] :: Credit -> [Link]

-- | <i>bookmark</i> child element
[creditBookmark] :: Credit -> [Bookmark]
[creditCredit] :: Credit -> ChxCredit
parseCredit :: XParse Credit

-- | Smart constructor for <a>Credit</a>
mkCredit :: ChxCredit -> Credit

-- | <tt>dashes</tt> <i>(complex)</i>
--   
--   The dashes type represents dashes, used for instance with cresc. and
--   dim. marks.
data Dashes
Dashes :: StartStopContinue -> Maybe NumberLevel -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Color -> Maybe ID -> Dashes

-- | <i>type</i> attribute
[dashesType] :: Dashes -> StartStopContinue

-- | <i>number</i> attribute
[dashesNumber] :: Dashes -> Maybe NumberLevel

-- | <i>dash-length</i> attribute
[dashesDashLength] :: Dashes -> Maybe Tenths

-- | <i>space-length</i> attribute
[dashesSpaceLength] :: Dashes -> Maybe Tenths

-- | <i>default-x</i> attribute
[dashesDefaultX] :: Dashes -> Maybe Tenths

-- | <i>default-y</i> attribute
[dashesDefaultY] :: Dashes -> Maybe Tenths

-- | <i>relative-x</i> attribute
[dashesRelativeX] :: Dashes -> Maybe Tenths

-- | <i>relative-y</i> attribute
[dashesRelativeY] :: Dashes -> Maybe Tenths

-- | <i>color</i> attribute
[dashesColor] :: Dashes -> Maybe Color

-- | <i>id</i> attribute
[dashesId] :: Dashes -> Maybe ID
parseDashes :: XParse Dashes

-- | Smart constructor for <a>Dashes</a>
mkDashes :: StartStopContinue -> Dashes

-- | <tt>defaults</tt> <i>(complex)</i>
--   
--   The defaults type specifies score-wide defaults for scaling, layout,
--   and appearance.
data Defaults
Defaults :: Maybe Scaling -> Layout -> Maybe Appearance -> Maybe EmptyFont -> Maybe EmptyFont -> [LyricFont] -> [LyricLanguage] -> Defaults

-- | <i>scaling</i> child element
[defaultsScaling] :: Defaults -> Maybe Scaling
[defaultsLayout] :: Defaults -> Layout

-- | <i>appearance</i> child element
[defaultsAppearance] :: Defaults -> Maybe Appearance

-- | <i>music-font</i> child element
[defaultsMusicFont] :: Defaults -> Maybe EmptyFont

-- | <i>word-font</i> child element
[defaultsWordFont] :: Defaults -> Maybe EmptyFont

-- | <i>lyric-font</i> child element
[defaultsLyricFont] :: Defaults -> [LyricFont]

-- | <i>lyric-language</i> child element
[defaultsLyricLanguage] :: Defaults -> [LyricLanguage]
parseDefaults :: XParse Defaults

-- | Smart constructor for <a>Defaults</a>
mkDefaults :: Layout -> Defaults

-- | <tt>degree</tt> <i>(complex)</i>
--   
--   The degree type is used to add, alter, or subtract individual notes in
--   the chord. The print-object attribute can be used to keep the degree
--   from printing separately when it has already taken into account in the
--   text attribute of the kind element. The degree-value and degree-type
--   text attributes specify how the value and type of the degree should be
--   displayed.
--   
--   A harmony of kind "other" can be spelled explicitly by using a series
--   of degree elements together with a root.
data Degree
Degree :: Maybe YesNo -> DegreeValue -> DegreeAlter -> DegreeType -> Degree

-- | <i>print-object</i> attribute
[degreePrintObject] :: Degree -> Maybe YesNo

-- | <i>degree-value</i> child element
[degreeDegreeValue] :: Degree -> DegreeValue

-- | <i>degree-alter</i> child element
[degreeDegreeAlter] :: Degree -> DegreeAlter

-- | <i>degree-type</i> child element
[degreeDegreeType] :: Degree -> DegreeType
parseDegree :: XParse Degree

-- | Smart constructor for <a>Degree</a>
mkDegree :: DegreeValue -> DegreeAlter -> DegreeType -> Degree

-- | <tt>degree-alter</tt> <i>(complex)</i>
--   
--   The degree-alter type represents the chromatic alteration for the
--   current degree. If the degree-type value is alter or subtract, the
--   degree-alter value is relative to the degree already in the chord
--   based on its kind element. If the degree-type value is add, the
--   degree-alter is relative to a dominant chord (major and perfect
--   intervals except for a minor seventh). The plus-minus attribute is
--   used to indicate if plus and minus symbols should be used instead of
--   sharp and flat symbols to display the degree alteration; it is no by
--   default.
data DegreeAlter
DegreeAlter :: Semitones -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> DegreeAlter

-- | text content
[degreeAlterSemitones] :: DegreeAlter -> Semitones

-- | <i>plus-minus</i> attribute
[degreeAlterPlusMinus] :: DegreeAlter -> Maybe YesNo

-- | <i>default-x</i> attribute
[degreeAlterDefaultX] :: DegreeAlter -> Maybe Tenths

-- | <i>default-y</i> attribute
[degreeAlterDefaultY] :: DegreeAlter -> Maybe Tenths

-- | <i>relative-x</i> attribute
[degreeAlterRelativeX] :: DegreeAlter -> Maybe Tenths

-- | <i>relative-y</i> attribute
[degreeAlterRelativeY] :: DegreeAlter -> Maybe Tenths

-- | <i>font-family</i> attribute
[degreeAlterFontFamily] :: DegreeAlter -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[degreeAlterFontStyle] :: DegreeAlter -> Maybe FontStyle

-- | <i>font-size</i> attribute
[degreeAlterFontSize] :: DegreeAlter -> Maybe FontSize

-- | <i>font-weight</i> attribute
[degreeAlterFontWeight] :: DegreeAlter -> Maybe FontWeight

-- | <i>color</i> attribute
[degreeAlterColor] :: DegreeAlter -> Maybe Color
parseDegreeAlter :: XParse DegreeAlter

-- | Smart constructor for <a>DegreeAlter</a>
mkDegreeAlter :: Semitones -> DegreeAlter

-- | <tt>degree-type</tt> <i>(complex)</i>
--   
--   The degree-type type indicates if this degree is an addition,
--   alteration, or subtraction relative to the kind of the current chord.
--   The value of the degree-type element affects the interpretation of the
--   value of the degree-alter element. The text attribute specifies how
--   the type of the degree should be displayed in a score.
data DegreeType
DegreeType :: DegreeTypeValue -> Maybe Token -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> DegreeType

-- | text content
[degreeTypeDegreeTypeValue] :: DegreeType -> DegreeTypeValue

-- | <i>text</i> attribute
[degreeTypeText] :: DegreeType -> Maybe Token

-- | <i>default-x</i> attribute
[degreeTypeDefaultX] :: DegreeType -> Maybe Tenths

-- | <i>default-y</i> attribute
[degreeTypeDefaultY] :: DegreeType -> Maybe Tenths

-- | <i>relative-x</i> attribute
[degreeTypeRelativeX] :: DegreeType -> Maybe Tenths

-- | <i>relative-y</i> attribute
[degreeTypeRelativeY] :: DegreeType -> Maybe Tenths

-- | <i>font-family</i> attribute
[degreeTypeFontFamily] :: DegreeType -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[degreeTypeFontStyle] :: DegreeType -> Maybe FontStyle

-- | <i>font-size</i> attribute
[degreeTypeFontSize] :: DegreeType -> Maybe FontSize

-- | <i>font-weight</i> attribute
[degreeTypeFontWeight] :: DegreeType -> Maybe FontWeight

-- | <i>color</i> attribute
[degreeTypeColor] :: DegreeType -> Maybe Color
parseDegreeType :: XParse DegreeType

-- | Smart constructor for <a>DegreeType</a>
mkDegreeType :: DegreeTypeValue -> DegreeType

-- | <tt>degree-value</tt> <i>(complex)</i>
--   
--   The content of the degree-value type is a number indicating the degree
--   of the chord (1 for the root, 3 for third, etc). The text attribute
--   specifies how the type of the degree should be displayed in a score.
--   The degree-value symbol attribute indicates that a symbol should be
--   used in specifying the degree. If the symbol attribute is present, the
--   value of the text attribute follows the symbol.
data DegreeValue
DegreeValue :: PositiveInteger -> Maybe DegreeSymbolValue -> Maybe Token -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> DegreeValue

-- | text content
[degreeValuePositiveInteger] :: DegreeValue -> PositiveInteger

-- | <i>symbol</i> attribute
[degreeValueSymbol] :: DegreeValue -> Maybe DegreeSymbolValue

-- | <i>text</i> attribute
[degreeValueText] :: DegreeValue -> Maybe Token

-- | <i>default-x</i> attribute
[degreeValueDefaultX] :: DegreeValue -> Maybe Tenths

-- | <i>default-y</i> attribute
[degreeValueDefaultY] :: DegreeValue -> Maybe Tenths

-- | <i>relative-x</i> attribute
[degreeValueRelativeX] :: DegreeValue -> Maybe Tenths

-- | <i>relative-y</i> attribute
[degreeValueRelativeY] :: DegreeValue -> Maybe Tenths

-- | <i>font-family</i> attribute
[degreeValueFontFamily] :: DegreeValue -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[degreeValueFontStyle] :: DegreeValue -> Maybe FontStyle

-- | <i>font-size</i> attribute
[degreeValueFontSize] :: DegreeValue -> Maybe FontSize

-- | <i>font-weight</i> attribute
[degreeValueFontWeight] :: DegreeValue -> Maybe FontWeight

-- | <i>color</i> attribute
[degreeValueColor] :: DegreeValue -> Maybe Color
parseDegreeValue :: XParse DegreeValue

-- | Smart constructor for <a>DegreeValue</a>
mkDegreeValue :: PositiveInteger -> DegreeValue

-- | <tt>direction</tt> <i>(complex)</i>
--   
--   A direction is a musical indication that is not necessarily attached
--   to a specific note. Two or more may be combined to indicate starts and
--   stops of wedges, dashes, etc. For applications where a specific
--   direction is indeed attached to a specific note, the direction element
--   can be associated with the note element that follows it in score order
--   that is not in a different voice.
--   
--   By default, a series of direction-type elements and a series of child
--   elements of a direction-type within a single direction element follow
--   one another in sequence visually. For a series of direction-type
--   children, non-positional formatting attributes are carried over from
--   the previous element by default.
data Direction
Direction :: Maybe AboveBelow -> Maybe YesNo -> Maybe ID -> [DirectionType] -> Maybe Offset -> EditorialVoiceDirection -> Maybe Staff -> Maybe Sound -> Direction

-- | <i>placement</i> attribute
[directionPlacement] :: Direction -> Maybe AboveBelow

-- | <i>directive</i> attribute
[directionDirective] :: Direction -> Maybe YesNo

-- | <i>id</i> attribute
[directionId] :: Direction -> Maybe ID

-- | <i>direction-type</i> child element
[directionDirectionType] :: Direction -> [DirectionType]

-- | <i>offset</i> child element
[directionOffset] :: Direction -> Maybe Offset
[directionEditorialVoiceDirection] :: Direction -> EditorialVoiceDirection
[directionStaff] :: Direction -> Maybe Staff

-- | <i>sound</i> child element
[directionSound] :: Direction -> Maybe Sound
parseDirection :: XParse Direction

-- | Smart constructor for <a>Direction</a>
mkDirection :: EditorialVoiceDirection -> Direction

-- | <tt>direction-type</tt> <i>(complex)</i>
--   
--   Textual direction types may have more than 1 component due to multiple
--   fonts. The dynamics element may also be used in the notations element.
--   Attribute groups related to print suggestions apply to the individual
--   direction-type, not to the overall direction.
data DirectionType
DirectionType :: Maybe ID -> ChxDirectionType -> DirectionType

-- | <i>id</i> attribute
[directionTypeId] :: DirectionType -> Maybe ID
[directionTypeDirectionType] :: DirectionType -> ChxDirectionType
parseDirectionType :: XParse DirectionType

-- | Smart constructor for <a>DirectionType</a>
mkDirectionType :: ChxDirectionType -> DirectionType

-- | <tt>directive</tt> <i>(complex)</i>
data Directive
Directive :: String -> Maybe Lang -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Directive

-- | text content
[directiveString] :: Directive -> String

-- | <i>xml:lang</i> attribute
[directiveLang] :: Directive -> Maybe Lang

-- | <i>default-x</i> attribute
[directiveDefaultX] :: Directive -> Maybe Tenths

-- | <i>default-y</i> attribute
[directiveDefaultY] :: Directive -> Maybe Tenths

-- | <i>relative-x</i> attribute
[directiveRelativeX] :: Directive -> Maybe Tenths

-- | <i>relative-y</i> attribute
[directiveRelativeY] :: Directive -> Maybe Tenths

-- | <i>font-family</i> attribute
[directiveFontFamily] :: Directive -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[directiveFontStyle] :: Directive -> Maybe FontStyle

-- | <i>font-size</i> attribute
[directiveFontSize] :: Directive -> Maybe FontSize

-- | <i>font-weight</i> attribute
[directiveFontWeight] :: Directive -> Maybe FontWeight

-- | <i>color</i> attribute
[directiveColor] :: Directive -> Maybe Color
parseDirective :: XParse Directive

-- | Smart constructor for <a>Directive</a>
mkDirective :: String -> Directive

-- | <tt>distance</tt> <i>(complex)</i>
--   
--   The distance element represents standard distances between notation
--   elements in tenths. The type attribute defines what type of distance
--   is being defined. Valid values include hyphen (for hyphens in lyrics)
--   and beam.
data Distance
Distance :: Tenths -> DistanceType -> Distance

-- | text content
[distanceTenths] :: Distance -> Tenths

-- | <i>type</i> attribute
[cmpdistanceType] :: Distance -> DistanceType
parseDistance :: XParse Distance

-- | Smart constructor for <a>Distance</a>
mkDistance :: Tenths -> DistanceType -> Distance

-- | <tt>dynamics</tt> <i>(complex)</i>
--   
--   Dynamics can be associated either with a note or a general musical
--   direction. To avoid inconsistencies between and amongst the letter
--   abbreviations for dynamics (what is sf vs. sfz, standing alone or with
--   a trailing dynamic that is not always piano), we use the actual
--   letters as the names of these dynamic elements. The other-dynamics
--   element allows other dynamic marks that are not covered here, but many
--   of those should perhaps be included in a more general musical
--   direction element. Dynamics elements may also be combined to create
--   marks not covered by a single element, such as sfmp.
--   
--   These letter dynamic symbols are separated from crescendo,
--   decrescendo, and wedge indications. Dynamic representation is
--   inconsistent in scores. Many things are assumed by the composer and
--   left out, such as returns to original dynamics. Systematic
--   representations are quite complex: for example, Humdrum has at least 3
--   representation formats related to dynamics. The MusicXML format
--   captures what is in the score, but does not try to be optimal for
--   analysis or synthesis of dynamics.
data Dynamics
Dynamics :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe AboveBelow -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe EnclosureShape -> Maybe ID -> [ChxDynamics] -> Dynamics

-- | <i>default-x</i> attribute
[dynamicsDefaultX] :: Dynamics -> Maybe Tenths

-- | <i>default-y</i> attribute
[dynamicsDefaultY] :: Dynamics -> Maybe Tenths

-- | <i>relative-x</i> attribute
[dynamicsRelativeX] :: Dynamics -> Maybe Tenths

-- | <i>relative-y</i> attribute
[dynamicsRelativeY] :: Dynamics -> Maybe Tenths

-- | <i>font-family</i> attribute
[dynamicsFontFamily] :: Dynamics -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[dynamicsFontStyle] :: Dynamics -> Maybe FontStyle

-- | <i>font-size</i> attribute
[dynamicsFontSize] :: Dynamics -> Maybe FontSize

-- | <i>font-weight</i> attribute
[dynamicsFontWeight] :: Dynamics -> Maybe FontWeight

-- | <i>color</i> attribute
[dynamicsColor] :: Dynamics -> Maybe Color

-- | <i>halign</i> attribute
[dynamicsHalign] :: Dynamics -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[dynamicsValign] :: Dynamics -> Maybe Valign

-- | <i>placement</i> attribute
[dynamicsPlacement] :: Dynamics -> Maybe AboveBelow

-- | <i>underline</i> attribute
[dynamicsUnderline] :: Dynamics -> Maybe NumberOfLines

-- | <i>overline</i> attribute
[dynamicsOverline] :: Dynamics -> Maybe NumberOfLines

-- | <i>line-through</i> attribute
[dynamicsLineThrough] :: Dynamics -> Maybe NumberOfLines

-- | <i>enclosure</i> attribute
[dynamicsEnclosure] :: Dynamics -> Maybe EnclosureShape

-- | <i>id</i> attribute
[dynamicsId] :: Dynamics -> Maybe ID
[dynamicsDynamics] :: Dynamics -> [ChxDynamics]
parseDynamics :: XParse Dynamics

-- | Smart constructor for <a>Dynamics</a>
mkDynamics :: Dynamics

-- | <tt>elision</tt> <i>(complex)</i>
--   
--   The elision type represents an elision between lyric syllables. The
--   text content specifies the symbol used to display the elision. Common
--   values are a no-break space (Unicode 00A0), an underscore (Unicode
--   005F), or an undertie (Unicode 203F). If the text content is empty,
--   the smufl attribute is used to specify the symbol to use. Its value is
--   a SMuFL canonical glyph name that starts with lyrics. The SMuFL
--   attribute is ignored if the elision glyph is already specified by the
--   text content. If neither text content nor a smufl attribute are
--   present, the elision glyph is application-specific.
data Elision
Elision :: String -> Maybe SmuflLyricsGlyphName -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Elision

-- | text content
[elisionString] :: Elision -> String

-- | <i>smufl</i> attribute
[elisionSmufl] :: Elision -> Maybe SmuflLyricsGlyphName

-- | <i>font-family</i> attribute
[elisionFontFamily] :: Elision -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[elisionFontStyle] :: Elision -> Maybe FontStyle

-- | <i>font-size</i> attribute
[elisionFontSize] :: Elision -> Maybe FontSize

-- | <i>font-weight</i> attribute
[elisionFontWeight] :: Elision -> Maybe FontWeight

-- | <i>color</i> attribute
[elisionColor] :: Elision -> Maybe Color
parseElision :: XParse Elision

-- | Smart constructor for <a>Elision</a>
mkElision :: String -> Elision

-- | <tt>empty</tt> <i>(complex)</i>
--   
--   The empty type represents an empty element with no attributes.
data Empty
Empty :: Empty
parseEmpty :: XParse Empty

-- | Smart constructor for <a>Empty</a>
mkEmpty :: Empty

-- | <tt>empty-font</tt> <i>(complex)</i>
--   
--   The empty-font type represents an empty element with font attributes.
data EmptyFont
EmptyFont :: Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> EmptyFont

-- | <i>font-family</i> attribute
[emptyFontFontFamily] :: EmptyFont -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[emptyFontFontStyle] :: EmptyFont -> Maybe FontStyle

-- | <i>font-size</i> attribute
[emptyFontFontSize] :: EmptyFont -> Maybe FontSize

-- | <i>font-weight</i> attribute
[emptyFontFontWeight] :: EmptyFont -> Maybe FontWeight
parseEmptyFont :: XParse EmptyFont

-- | Smart constructor for <a>EmptyFont</a>
mkEmptyFont :: EmptyFont

-- | <tt>empty-line</tt> <i>(complex)</i>
--   
--   The empty-line type represents an empty element with line-shape,
--   line-type, line-length, dashed-formatting, print-style and placement
--   attributes.
data EmptyLine
EmptyLine :: Maybe LineShape -> Maybe LineType -> Maybe LineLength -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> EmptyLine

-- | <i>line-shape</i> attribute
[emptyLineLineShape] :: EmptyLine -> Maybe LineShape

-- | <i>line-type</i> attribute
[emptyLineLineType] :: EmptyLine -> Maybe LineType

-- | <i>line-length</i> attribute
[emptyLineLineLength] :: EmptyLine -> Maybe LineLength

-- | <i>dash-length</i> attribute
[emptyLineDashLength] :: EmptyLine -> Maybe Tenths

-- | <i>space-length</i> attribute
[emptyLineSpaceLength] :: EmptyLine -> Maybe Tenths

-- | <i>default-x</i> attribute
[emptyLineDefaultX] :: EmptyLine -> Maybe Tenths

-- | <i>default-y</i> attribute
[emptyLineDefaultY] :: EmptyLine -> Maybe Tenths

-- | <i>relative-x</i> attribute
[emptyLineRelativeX] :: EmptyLine -> Maybe Tenths

-- | <i>relative-y</i> attribute
[emptyLineRelativeY] :: EmptyLine -> Maybe Tenths

-- | <i>font-family</i> attribute
[emptyLineFontFamily] :: EmptyLine -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[emptyLineFontStyle] :: EmptyLine -> Maybe FontStyle

-- | <i>font-size</i> attribute
[emptyLineFontSize] :: EmptyLine -> Maybe FontSize

-- | <i>font-weight</i> attribute
[emptyLineFontWeight] :: EmptyLine -> Maybe FontWeight

-- | <i>color</i> attribute
[emptyLineColor] :: EmptyLine -> Maybe Color

-- | <i>placement</i> attribute
[emptyLinePlacement] :: EmptyLine -> Maybe AboveBelow
parseEmptyLine :: XParse EmptyLine

-- | Smart constructor for <a>EmptyLine</a>
mkEmptyLine :: EmptyLine

-- | <tt>empty-placement</tt> <i>(complex)</i>
--   
--   The empty-placement type represents an empty element with print-style
--   and placement attributes.
data EmptyPlacement
EmptyPlacement :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> EmptyPlacement

-- | <i>default-x</i> attribute
[emptyPlacementDefaultX] :: EmptyPlacement -> Maybe Tenths

-- | <i>default-y</i> attribute
[emptyPlacementDefaultY] :: EmptyPlacement -> Maybe Tenths

-- | <i>relative-x</i> attribute
[emptyPlacementRelativeX] :: EmptyPlacement -> Maybe Tenths

-- | <i>relative-y</i> attribute
[emptyPlacementRelativeY] :: EmptyPlacement -> Maybe Tenths

-- | <i>font-family</i> attribute
[emptyPlacementFontFamily] :: EmptyPlacement -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[emptyPlacementFontStyle] :: EmptyPlacement -> Maybe FontStyle

-- | <i>font-size</i> attribute
[emptyPlacementFontSize] :: EmptyPlacement -> Maybe FontSize

-- | <i>font-weight</i> attribute
[emptyPlacementFontWeight] :: EmptyPlacement -> Maybe FontWeight

-- | <i>color</i> attribute
[emptyPlacementColor] :: EmptyPlacement -> Maybe Color

-- | <i>placement</i> attribute
[emptyPlacementPlacement] :: EmptyPlacement -> Maybe AboveBelow
parseEmptyPlacement :: XParse EmptyPlacement

-- | Smart constructor for <a>EmptyPlacement</a>
mkEmptyPlacement :: EmptyPlacement

-- | <tt>empty-placement-smufl</tt> <i>(complex)</i>
--   
--   The empty-placement-smufl type represents an empty element with
--   print-style, placement, and smufl attributes.
data EmptyPlacementSmufl
EmptyPlacementSmufl :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe SmuflGlyphName -> EmptyPlacementSmufl

-- | <i>default-x</i> attribute
[emptyPlacementSmuflDefaultX] :: EmptyPlacementSmufl -> Maybe Tenths

-- | <i>default-y</i> attribute
[emptyPlacementSmuflDefaultY] :: EmptyPlacementSmufl -> Maybe Tenths

-- | <i>relative-x</i> attribute
[emptyPlacementSmuflRelativeX] :: EmptyPlacementSmufl -> Maybe Tenths

-- | <i>relative-y</i> attribute
[emptyPlacementSmuflRelativeY] :: EmptyPlacementSmufl -> Maybe Tenths

-- | <i>font-family</i> attribute
[emptyPlacementSmuflFontFamily] :: EmptyPlacementSmufl -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[emptyPlacementSmuflFontStyle] :: EmptyPlacementSmufl -> Maybe FontStyle

-- | <i>font-size</i> attribute
[emptyPlacementSmuflFontSize] :: EmptyPlacementSmufl -> Maybe FontSize

-- | <i>font-weight</i> attribute
[emptyPlacementSmuflFontWeight] :: EmptyPlacementSmufl -> Maybe FontWeight

-- | <i>color</i> attribute
[emptyPlacementSmuflColor] :: EmptyPlacementSmufl -> Maybe Color

-- | <i>placement</i> attribute
[emptyPlacementSmuflPlacement] :: EmptyPlacementSmufl -> Maybe AboveBelow

-- | <i>smufl</i> attribute
[emptyPlacementSmuflSmufl] :: EmptyPlacementSmufl -> Maybe SmuflGlyphName
parseEmptyPlacementSmufl :: XParse EmptyPlacementSmufl

-- | Smart constructor for <a>EmptyPlacementSmufl</a>
mkEmptyPlacementSmufl :: EmptyPlacementSmufl

-- | <tt>empty-print-object-style-align</tt> <i>(complex)</i>
--   
--   The empty-print-style-align-object type represents an empty element
--   with print-object and print-style-align attribute groups.
data EmptyPrintObjectStyleAlign
EmptyPrintObjectStyleAlign :: Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> EmptyPrintObjectStyleAlign

-- | <i>print-object</i> attribute
[emptyPrintObjectStyleAlignPrintObject] :: EmptyPrintObjectStyleAlign -> Maybe YesNo

-- | <i>default-x</i> attribute
[emptyPrintObjectStyleAlignDefaultX] :: EmptyPrintObjectStyleAlign -> Maybe Tenths

-- | <i>default-y</i> attribute
[emptyPrintObjectStyleAlignDefaultY] :: EmptyPrintObjectStyleAlign -> Maybe Tenths

-- | <i>relative-x</i> attribute
[emptyPrintObjectStyleAlignRelativeX] :: EmptyPrintObjectStyleAlign -> Maybe Tenths

-- | <i>relative-y</i> attribute
[emptyPrintObjectStyleAlignRelativeY] :: EmptyPrintObjectStyleAlign -> Maybe Tenths

-- | <i>font-family</i> attribute
[emptyPrintObjectStyleAlignFontFamily] :: EmptyPrintObjectStyleAlign -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[emptyPrintObjectStyleAlignFontStyle] :: EmptyPrintObjectStyleAlign -> Maybe FontStyle

-- | <i>font-size</i> attribute
[emptyPrintObjectStyleAlignFontSize] :: EmptyPrintObjectStyleAlign -> Maybe FontSize

-- | <i>font-weight</i> attribute
[emptyPrintObjectStyleAlignFontWeight] :: EmptyPrintObjectStyleAlign -> Maybe FontWeight

-- | <i>color</i> attribute
[emptyPrintObjectStyleAlignColor] :: EmptyPrintObjectStyleAlign -> Maybe Color

-- | <i>halign</i> attribute
[emptyPrintObjectStyleAlignHalign] :: EmptyPrintObjectStyleAlign -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[emptyPrintObjectStyleAlignValign] :: EmptyPrintObjectStyleAlign -> Maybe Valign
parseEmptyPrintObjectStyleAlign :: XParse EmptyPrintObjectStyleAlign

-- | Smart constructor for <a>EmptyPrintObjectStyleAlign</a>
mkEmptyPrintObjectStyleAlign :: EmptyPrintObjectStyleAlign

-- | <tt>empty-print-style-align-id</tt> <i>(complex)</i>
--   
--   The empty-print-style-align-id type represents an empty element with
--   print-style-align and optional-unique-id attribute groups.
data EmptyPrintStyleAlignId
EmptyPrintStyleAlignId :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> EmptyPrintStyleAlignId

-- | <i>default-x</i> attribute
[emptyPrintStyleAlignIdDefaultX] :: EmptyPrintStyleAlignId -> Maybe Tenths

-- | <i>default-y</i> attribute
[emptyPrintStyleAlignIdDefaultY] :: EmptyPrintStyleAlignId -> Maybe Tenths

-- | <i>relative-x</i> attribute
[emptyPrintStyleAlignIdRelativeX] :: EmptyPrintStyleAlignId -> Maybe Tenths

-- | <i>relative-y</i> attribute
[emptyPrintStyleAlignIdRelativeY] :: EmptyPrintStyleAlignId -> Maybe Tenths

-- | <i>font-family</i> attribute
[emptyPrintStyleAlignIdFontFamily] :: EmptyPrintStyleAlignId -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[emptyPrintStyleAlignIdFontStyle] :: EmptyPrintStyleAlignId -> Maybe FontStyle

-- | <i>font-size</i> attribute
[emptyPrintStyleAlignIdFontSize] :: EmptyPrintStyleAlignId -> Maybe FontSize

-- | <i>font-weight</i> attribute
[emptyPrintStyleAlignIdFontWeight] :: EmptyPrintStyleAlignId -> Maybe FontWeight

-- | <i>color</i> attribute
[emptyPrintStyleAlignIdColor] :: EmptyPrintStyleAlignId -> Maybe Color

-- | <i>halign</i> attribute
[emptyPrintStyleAlignIdHalign] :: EmptyPrintStyleAlignId -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[emptyPrintStyleAlignIdValign] :: EmptyPrintStyleAlignId -> Maybe Valign

-- | <i>id</i> attribute
[emptyPrintStyleAlignIdId] :: EmptyPrintStyleAlignId -> Maybe ID
parseEmptyPrintStyleAlignId :: XParse EmptyPrintStyleAlignId

-- | Smart constructor for <a>EmptyPrintStyleAlignId</a>
mkEmptyPrintStyleAlignId :: EmptyPrintStyleAlignId

-- | <tt>empty-trill-sound</tt> <i>(complex)</i>
--   
--   The empty-trill-sound type represents an empty element with
--   print-style, placement, and trill-sound attributes.
data EmptyTrillSound
EmptyTrillSound :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe StartNote -> Maybe TrillStep -> Maybe TwoNoteTurn -> Maybe YesNo -> Maybe TrillBeats -> Maybe Percent -> Maybe Percent -> EmptyTrillSound

-- | <i>default-x</i> attribute
[emptyTrillSoundDefaultX] :: EmptyTrillSound -> Maybe Tenths

-- | <i>default-y</i> attribute
[emptyTrillSoundDefaultY] :: EmptyTrillSound -> Maybe Tenths

-- | <i>relative-x</i> attribute
[emptyTrillSoundRelativeX] :: EmptyTrillSound -> Maybe Tenths

-- | <i>relative-y</i> attribute
[emptyTrillSoundRelativeY] :: EmptyTrillSound -> Maybe Tenths

-- | <i>font-family</i> attribute
[emptyTrillSoundFontFamily] :: EmptyTrillSound -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[emptyTrillSoundFontStyle] :: EmptyTrillSound -> Maybe FontStyle

-- | <i>font-size</i> attribute
[emptyTrillSoundFontSize] :: EmptyTrillSound -> Maybe FontSize

-- | <i>font-weight</i> attribute
[emptyTrillSoundFontWeight] :: EmptyTrillSound -> Maybe FontWeight

-- | <i>color</i> attribute
[emptyTrillSoundColor] :: EmptyTrillSound -> Maybe Color

-- | <i>placement</i> attribute
[emptyTrillSoundPlacement] :: EmptyTrillSound -> Maybe AboveBelow

-- | <i>start-note</i> attribute
[emptyTrillSoundStartNote] :: EmptyTrillSound -> Maybe StartNote

-- | <i>trill-step</i> attribute
[emptyTrillSoundTrillStep] :: EmptyTrillSound -> Maybe TrillStep

-- | <i>two-note-turn</i> attribute
[emptyTrillSoundTwoNoteTurn] :: EmptyTrillSound -> Maybe TwoNoteTurn

-- | <i>accelerate</i> attribute
[emptyTrillSoundAccelerate] :: EmptyTrillSound -> Maybe YesNo

-- | <i>beats</i> attribute
[emptyTrillSoundBeats] :: EmptyTrillSound -> Maybe TrillBeats

-- | <i>second-beat</i> attribute
[emptyTrillSoundSecondBeat] :: EmptyTrillSound -> Maybe Percent

-- | <i>last-beat</i> attribute
[emptyTrillSoundLastBeat] :: EmptyTrillSound -> Maybe Percent
parseEmptyTrillSound :: XParse EmptyTrillSound

-- | Smart constructor for <a>EmptyTrillSound</a>
mkEmptyTrillSound :: EmptyTrillSound

-- | <tt>encoding</tt> <i>(complex)</i>
--   
--   The encoding element contains information about who did the digital
--   encoding, when, with what software, and in what aspects. Standard type
--   values for the encoder element are music, words, and arrangement, but
--   other types may be used. The type attribute is only needed when there
--   are multiple encoder elements.
data Encoding
Encoding :: [ChxEncoding] -> Encoding
[encodingEncoding] :: Encoding -> [ChxEncoding]
parseEncoding :: XParse Encoding

-- | Smart constructor for <a>Encoding</a>
mkEncoding :: Encoding

-- | <tt>ending</tt> <i>(complex)</i>
--   
--   The ending type represents multiple (e.g. first and second) endings.
--   Typically, the start type is associated with the left barline of the
--   first measure in an ending. The stop and discontinue types are
--   associated with the right barline of the last measure in an ending.
--   Stop is used when the ending mark concludes with a downward jog, as is
--   typical for first endings. Discontinue is used when there is no
--   downward jog, as is typical for second endings that do not conclude a
--   piece. The length of the jog can be specified using the end-length
--   attribute. The text-x and text-y attributes are offsets that specify
--   where the baseline of the start of the ending text appears, relative
--   to the start of the ending line.
--   
--   The number attribute reflects the numeric values of what is under the
--   ending line. Single endings such as "1" or comma-separated multiple
--   endings such as "1,2" may be used. The ending element text is used
--   when the text displayed in the ending is different than what appears
--   in the number attribute. The print-object element is used to indicate
--   when an ending is present but not printed, as is often the case for
--   many parts in a full score.
data Ending
Ending :: String -> EndingNumber -> StartStopDiscontinue -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Ending

-- | text content
[endingString] :: Ending -> String

-- | <i>number</i> attribute
[cmpendingNumber] :: Ending -> EndingNumber

-- | <i>type</i> attribute
[endingType] :: Ending -> StartStopDiscontinue

-- | <i>end-length</i> attribute
[endingEndLength] :: Ending -> Maybe Tenths

-- | <i>text-x</i> attribute
[endingTextX] :: Ending -> Maybe Tenths

-- | <i>text-y</i> attribute
[endingTextY] :: Ending -> Maybe Tenths

-- | <i>print-object</i> attribute
[endingPrintObject] :: Ending -> Maybe YesNo

-- | <i>default-x</i> attribute
[endingDefaultX] :: Ending -> Maybe Tenths

-- | <i>default-y</i> attribute
[endingDefaultY] :: Ending -> Maybe Tenths

-- | <i>relative-x</i> attribute
[endingRelativeX] :: Ending -> Maybe Tenths

-- | <i>relative-y</i> attribute
[endingRelativeY] :: Ending -> Maybe Tenths

-- | <i>font-family</i> attribute
[endingFontFamily] :: Ending -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[endingFontStyle] :: Ending -> Maybe FontStyle

-- | <i>font-size</i> attribute
[endingFontSize] :: Ending -> Maybe FontSize

-- | <i>font-weight</i> attribute
[endingFontWeight] :: Ending -> Maybe FontWeight

-- | <i>color</i> attribute
[endingColor] :: Ending -> Maybe Color
parseEnding :: XParse Ending

-- | Smart constructor for <a>Ending</a>
mkEnding :: String -> EndingNumber -> StartStopDiscontinue -> Ending

-- | <tt>extend</tt> <i>(complex)</i>
--   
--   The extend type represents lyric word extension / melisma lines as
--   well as figured bass extensions. The optional type and position
--   attributes are added in Version 3.0 to provide better formatting
--   control.
data Extend
Extend :: Maybe StartStopContinue -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Color -> Extend

-- | <i>type</i> attribute
[extendType] :: Extend -> Maybe StartStopContinue

-- | <i>default-x</i> attribute
[extendDefaultX] :: Extend -> Maybe Tenths

-- | <i>default-y</i> attribute
[extendDefaultY] :: Extend -> Maybe Tenths

-- | <i>relative-x</i> attribute
[extendRelativeX] :: Extend -> Maybe Tenths

-- | <i>relative-y</i> attribute
[extendRelativeY] :: Extend -> Maybe Tenths

-- | <i>color</i> attribute
[extendColor] :: Extend -> Maybe Color
parseExtend :: XParse Extend

-- | Smart constructor for <a>Extend</a>
mkExtend :: Extend

-- | <tt>feature</tt> <i>(complex)</i>
--   
--   The feature type is a part of the grouping element used for musical
--   analysis. The type attribute represents the type of the feature and
--   the element content represents its value. This type is flexible to
--   allow for different analyses.
data Feature
Feature :: String -> Maybe Token -> Feature

-- | text content
[featureString] :: Feature -> String

-- | <i>type</i> attribute
[featureType] :: Feature -> Maybe Token
parseFeature :: XParse Feature

-- | Smart constructor for <a>Feature</a>
mkFeature :: String -> Feature

-- | <tt>fermata</tt> <i>(complex)</i>
--   
--   The fermata text content represents the shape of the fermata sign. An
--   empty fermata element represents a normal fermata. The fermata type is
--   upright if not specified.
data Fermata
Fermata :: FermataShape -> Maybe UprightInverted -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe ID -> Fermata

-- | text content
[fermataFermataShape] :: Fermata -> FermataShape

-- | <i>type</i> attribute
[fermataType] :: Fermata -> Maybe UprightInverted

-- | <i>default-x</i> attribute
[fermataDefaultX] :: Fermata -> Maybe Tenths

-- | <i>default-y</i> attribute
[fermataDefaultY] :: Fermata -> Maybe Tenths

-- | <i>relative-x</i> attribute
[fermataRelativeX] :: Fermata -> Maybe Tenths

-- | <i>relative-y</i> attribute
[fermataRelativeY] :: Fermata -> Maybe Tenths

-- | <i>font-family</i> attribute
[fermataFontFamily] :: Fermata -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[fermataFontStyle] :: Fermata -> Maybe FontStyle

-- | <i>font-size</i> attribute
[fermataFontSize] :: Fermata -> Maybe FontSize

-- | <i>font-weight</i> attribute
[fermataFontWeight] :: Fermata -> Maybe FontWeight

-- | <i>color</i> attribute
[fermataColor] :: Fermata -> Maybe Color

-- | <i>id</i> attribute
[fermataId] :: Fermata -> Maybe ID
parseFermata :: XParse Fermata

-- | Smart constructor for <a>Fermata</a>
mkFermata :: FermataShape -> Fermata

-- | <tt>figure</tt> <i>(complex)</i>
--   
--   The figure type represents a single figure within a figured-bass
--   element.
data Figure
Figure :: Maybe StyleText -> Maybe StyleText -> Maybe StyleText -> Maybe Extend -> Editorial -> Figure

-- | <i>prefix</i> child element
[figurePrefix] :: Figure -> Maybe StyleText

-- | <i>figure-number</i> child element
[figureFigureNumber] :: Figure -> Maybe StyleText

-- | <i>suffix</i> child element
[figureSuffix] :: Figure -> Maybe StyleText

-- | <i>extend</i> child element
[figureExtend] :: Figure -> Maybe Extend
[figureEditorial] :: Figure -> Editorial
parseFigure :: XParse Figure

-- | Smart constructor for <a>Figure</a>
mkFigure :: Editorial -> Figure

-- | <tt>figured-bass</tt> <i>(complex)</i>
--   
--   The figured-bass element represents figured bass notation. Figured
--   bass elements take their position from the first regular note (not a
--   grace note or chord note) that follows in score order. The optional
--   duration element is used to indicate changes of figures under a note.
--   
--   Figures are ordered from top to bottom. The value of parentheses is
--   "no" if not present.
data FiguredBass
FiguredBass :: Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe YesNo -> Maybe YesNo -> Maybe YesNo -> Maybe YesNo -> Maybe ID -> [Figure] -> Maybe Duration -> Editorial -> FiguredBass

-- | <i>parentheses</i> attribute
[figuredBassParentheses] :: FiguredBass -> Maybe YesNo

-- | <i>default-x</i> attribute
[figuredBassDefaultX] :: FiguredBass -> Maybe Tenths

-- | <i>default-y</i> attribute
[figuredBassDefaultY] :: FiguredBass -> Maybe Tenths

-- | <i>relative-x</i> attribute
[figuredBassRelativeX] :: FiguredBass -> Maybe Tenths

-- | <i>relative-y</i> attribute
[figuredBassRelativeY] :: FiguredBass -> Maybe Tenths

-- | <i>font-family</i> attribute
[figuredBassFontFamily] :: FiguredBass -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[figuredBassFontStyle] :: FiguredBass -> Maybe FontStyle

-- | <i>font-size</i> attribute
[figuredBassFontSize] :: FiguredBass -> Maybe FontSize

-- | <i>font-weight</i> attribute
[figuredBassFontWeight] :: FiguredBass -> Maybe FontWeight

-- | <i>color</i> attribute
[figuredBassColor] :: FiguredBass -> Maybe Color

-- | <i>print-dot</i> attribute
[figuredBassPrintDot] :: FiguredBass -> Maybe YesNo

-- | <i>print-lyric</i> attribute
[figuredBassPrintLyric] :: FiguredBass -> Maybe YesNo

-- | <i>print-object</i> attribute
[figuredBassPrintObject] :: FiguredBass -> Maybe YesNo

-- | <i>print-spacing</i> attribute
[figuredBassPrintSpacing] :: FiguredBass -> Maybe YesNo

-- | <i>id</i> attribute
[figuredBassId] :: FiguredBass -> Maybe ID

-- | <i>figure</i> child element
[figuredBassFigure] :: FiguredBass -> [Figure]
[figuredBassDuration] :: FiguredBass -> Maybe Duration
[figuredBassEditorial] :: FiguredBass -> Editorial
parseFiguredBass :: XParse FiguredBass

-- | Smart constructor for <a>FiguredBass</a>
mkFiguredBass :: Editorial -> FiguredBass

-- | <tt>fingering</tt> <i>(complex)</i>
--   
--   Fingering is typically indicated 1,2,3,4,5. Multiple fingerings may be
--   given, typically to substitute fingerings in the middle of a note. The
--   substitution and alternate values are "no" if the attribute is not
--   present. For guitar and other fretted instruments, the fingering
--   element represents the fretting finger; the pluck element represents
--   the plucking finger.
data Fingering
Fingering :: String -> Maybe YesNo -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Fingering

-- | text content
[fingeringString] :: Fingering -> String

-- | <i>substitution</i> attribute
[fingeringSubstitution] :: Fingering -> Maybe YesNo

-- | <i>alternate</i> attribute
[fingeringAlternate] :: Fingering -> Maybe YesNo

-- | <i>default-x</i> attribute
[fingeringDefaultX] :: Fingering -> Maybe Tenths

-- | <i>default-y</i> attribute
[fingeringDefaultY] :: Fingering -> Maybe Tenths

-- | <i>relative-x</i> attribute
[fingeringRelativeX] :: Fingering -> Maybe Tenths

-- | <i>relative-y</i> attribute
[fingeringRelativeY] :: Fingering -> Maybe Tenths

-- | <i>font-family</i> attribute
[fingeringFontFamily] :: Fingering -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[fingeringFontStyle] :: Fingering -> Maybe FontStyle

-- | <i>font-size</i> attribute
[fingeringFontSize] :: Fingering -> Maybe FontSize

-- | <i>font-weight</i> attribute
[fingeringFontWeight] :: Fingering -> Maybe FontWeight

-- | <i>color</i> attribute
[fingeringColor] :: Fingering -> Maybe Color

-- | <i>placement</i> attribute
[fingeringPlacement] :: Fingering -> Maybe AboveBelow
parseFingering :: XParse Fingering

-- | Smart constructor for <a>Fingering</a>
mkFingering :: String -> Fingering

-- | <tt>first-fret</tt> <i>(complex)</i>
--   
--   The first-fret type indicates which fret is shown in the top space of
--   the frame; it is fret 1 if the element is not present. The optional
--   text attribute indicates how this is represented in the fret diagram,
--   while the location attribute indicates whether the text appears to the
--   left or right of the frame.
data FirstFret
FirstFret :: PositiveInteger -> Maybe Token -> Maybe LeftRight -> FirstFret

-- | text content
[firstFretPositiveInteger] :: FirstFret -> PositiveInteger

-- | <i>text</i> attribute
[firstFretText] :: FirstFret -> Maybe Token

-- | <i>location</i> attribute
[firstFretLocation] :: FirstFret -> Maybe LeftRight
parseFirstFret :: XParse FirstFret

-- | Smart constructor for <a>FirstFret</a>
mkFirstFret :: PositiveInteger -> FirstFret

-- | <tt>formatted-symbol-id</tt> <i>(complex)</i>
--   
--   The formatted-symbol-id type represents a SMuFL musical symbol element
--   with formatting and id attributes.
data FormattedSymbolId
FormattedSymbolId :: SmuflGlyphName -> Maybe LeftCenterRight -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe RotationDegrees -> Maybe NumberOrNormal -> Maybe NumberOrNormal -> Maybe TextDirection -> Maybe EnclosureShape -> Maybe ID -> FormattedSymbolId

-- | text content
[formattedSymbolIdSmuflGlyphName] :: FormattedSymbolId -> SmuflGlyphName

-- | <i>justify</i> attribute
[formattedSymbolIdJustify] :: FormattedSymbolId -> Maybe LeftCenterRight

-- | <i>default-x</i> attribute
[formattedSymbolIdDefaultX] :: FormattedSymbolId -> Maybe Tenths

-- | <i>default-y</i> attribute
[formattedSymbolIdDefaultY] :: FormattedSymbolId -> Maybe Tenths

-- | <i>relative-x</i> attribute
[formattedSymbolIdRelativeX] :: FormattedSymbolId -> Maybe Tenths

-- | <i>relative-y</i> attribute
[formattedSymbolIdRelativeY] :: FormattedSymbolId -> Maybe Tenths

-- | <i>font-family</i> attribute
[formattedSymbolIdFontFamily] :: FormattedSymbolId -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[formattedSymbolIdFontStyle] :: FormattedSymbolId -> Maybe FontStyle

-- | <i>font-size</i> attribute
[formattedSymbolIdFontSize] :: FormattedSymbolId -> Maybe FontSize

-- | <i>font-weight</i> attribute
[formattedSymbolIdFontWeight] :: FormattedSymbolId -> Maybe FontWeight

-- | <i>color</i> attribute
[formattedSymbolIdColor] :: FormattedSymbolId -> Maybe Color

-- | <i>halign</i> attribute
[formattedSymbolIdHalign] :: FormattedSymbolId -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[formattedSymbolIdValign] :: FormattedSymbolId -> Maybe Valign

-- | <i>underline</i> attribute
[formattedSymbolIdUnderline] :: FormattedSymbolId -> Maybe NumberOfLines

-- | <i>overline</i> attribute
[formattedSymbolIdOverline] :: FormattedSymbolId -> Maybe NumberOfLines

-- | <i>line-through</i> attribute
[formattedSymbolIdLineThrough] :: FormattedSymbolId -> Maybe NumberOfLines

-- | <i>rotation</i> attribute
[formattedSymbolIdRotation] :: FormattedSymbolId -> Maybe RotationDegrees

-- | <i>letter-spacing</i> attribute
[formattedSymbolIdLetterSpacing] :: FormattedSymbolId -> Maybe NumberOrNormal

-- | <i>line-height</i> attribute
[formattedSymbolIdLineHeight] :: FormattedSymbolId -> Maybe NumberOrNormal

-- | <i>dir</i> attribute
[formattedSymbolIdDir] :: FormattedSymbolId -> Maybe TextDirection

-- | <i>enclosure</i> attribute
[formattedSymbolIdEnclosure] :: FormattedSymbolId -> Maybe EnclosureShape

-- | <i>id</i> attribute
[formattedSymbolIdId] :: FormattedSymbolId -> Maybe ID
parseFormattedSymbolId :: XParse FormattedSymbolId

-- | Smart constructor for <a>FormattedSymbolId</a>
mkFormattedSymbolId :: SmuflGlyphName -> FormattedSymbolId

-- | <tt>formatted-text</tt> <i>(complex)</i>
--   
--   The formatted-text type represents a text element with text-formatting
--   attributes.
data FormattedText
FormattedText :: String -> Maybe Lang -> Maybe Space -> Maybe LeftCenterRight -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe RotationDegrees -> Maybe NumberOrNormal -> Maybe NumberOrNormal -> Maybe TextDirection -> Maybe EnclosureShape -> FormattedText

-- | text content
[formattedTextString] :: FormattedText -> String

-- | <i>xml:lang</i> attribute
[formattedTextLang] :: FormattedText -> Maybe Lang

-- | <i>xml:space</i> attribute
[formattedTextSpace] :: FormattedText -> Maybe Space

-- | <i>justify</i> attribute
[formattedTextJustify] :: FormattedText -> Maybe LeftCenterRight

-- | <i>default-x</i> attribute
[formattedTextDefaultX] :: FormattedText -> Maybe Tenths

-- | <i>default-y</i> attribute
[formattedTextDefaultY] :: FormattedText -> Maybe Tenths

-- | <i>relative-x</i> attribute
[formattedTextRelativeX] :: FormattedText -> Maybe Tenths

-- | <i>relative-y</i> attribute
[formattedTextRelativeY] :: FormattedText -> Maybe Tenths

-- | <i>font-family</i> attribute
[formattedTextFontFamily] :: FormattedText -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[formattedTextFontStyle] :: FormattedText -> Maybe FontStyle

-- | <i>font-size</i> attribute
[formattedTextFontSize] :: FormattedText -> Maybe FontSize

-- | <i>font-weight</i> attribute
[formattedTextFontWeight] :: FormattedText -> Maybe FontWeight

-- | <i>color</i> attribute
[formattedTextColor] :: FormattedText -> Maybe Color

-- | <i>halign</i> attribute
[formattedTextHalign] :: FormattedText -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[formattedTextValign] :: FormattedText -> Maybe Valign

-- | <i>underline</i> attribute
[formattedTextUnderline] :: FormattedText -> Maybe NumberOfLines

-- | <i>overline</i> attribute
[formattedTextOverline] :: FormattedText -> Maybe NumberOfLines

-- | <i>line-through</i> attribute
[formattedTextLineThrough] :: FormattedText -> Maybe NumberOfLines

-- | <i>rotation</i> attribute
[formattedTextRotation] :: FormattedText -> Maybe RotationDegrees

-- | <i>letter-spacing</i> attribute
[formattedTextLetterSpacing] :: FormattedText -> Maybe NumberOrNormal

-- | <i>line-height</i> attribute
[formattedTextLineHeight] :: FormattedText -> Maybe NumberOrNormal

-- | <i>dir</i> attribute
[formattedTextDir] :: FormattedText -> Maybe TextDirection

-- | <i>enclosure</i> attribute
[formattedTextEnclosure] :: FormattedText -> Maybe EnclosureShape
parseFormattedText :: XParse FormattedText

-- | Smart constructor for <a>FormattedText</a>
mkFormattedText :: String -> FormattedText

-- | <tt>formatted-text-id</tt> <i>(complex)</i>
--   
--   The formatted-text-id type represents a text element with
--   text-formatting and id attributes.
data FormattedTextId
FormattedTextId :: String -> Maybe Lang -> Maybe Space -> Maybe LeftCenterRight -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe RotationDegrees -> Maybe NumberOrNormal -> Maybe NumberOrNormal -> Maybe TextDirection -> Maybe EnclosureShape -> Maybe ID -> FormattedTextId

-- | text content
[formattedTextIdString] :: FormattedTextId -> String

-- | <i>xml:lang</i> attribute
[formattedTextIdLang] :: FormattedTextId -> Maybe Lang

-- | <i>xml:space</i> attribute
[formattedTextIdSpace] :: FormattedTextId -> Maybe Space

-- | <i>justify</i> attribute
[formattedTextIdJustify] :: FormattedTextId -> Maybe LeftCenterRight

-- | <i>default-x</i> attribute
[formattedTextIdDefaultX] :: FormattedTextId -> Maybe Tenths

-- | <i>default-y</i> attribute
[formattedTextIdDefaultY] :: FormattedTextId -> Maybe Tenths

-- | <i>relative-x</i> attribute
[formattedTextIdRelativeX] :: FormattedTextId -> Maybe Tenths

-- | <i>relative-y</i> attribute
[formattedTextIdRelativeY] :: FormattedTextId -> Maybe Tenths

-- | <i>font-family</i> attribute
[formattedTextIdFontFamily] :: FormattedTextId -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[formattedTextIdFontStyle] :: FormattedTextId -> Maybe FontStyle

-- | <i>font-size</i> attribute
[formattedTextIdFontSize] :: FormattedTextId -> Maybe FontSize

-- | <i>font-weight</i> attribute
[formattedTextIdFontWeight] :: FormattedTextId -> Maybe FontWeight

-- | <i>color</i> attribute
[formattedTextIdColor] :: FormattedTextId -> Maybe Color

-- | <i>halign</i> attribute
[formattedTextIdHalign] :: FormattedTextId -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[formattedTextIdValign] :: FormattedTextId -> Maybe Valign

-- | <i>underline</i> attribute
[formattedTextIdUnderline] :: FormattedTextId -> Maybe NumberOfLines

-- | <i>overline</i> attribute
[formattedTextIdOverline] :: FormattedTextId -> Maybe NumberOfLines

-- | <i>line-through</i> attribute
[formattedTextIdLineThrough] :: FormattedTextId -> Maybe NumberOfLines

-- | <i>rotation</i> attribute
[formattedTextIdRotation] :: FormattedTextId -> Maybe RotationDegrees

-- | <i>letter-spacing</i> attribute
[formattedTextIdLetterSpacing] :: FormattedTextId -> Maybe NumberOrNormal

-- | <i>line-height</i> attribute
[formattedTextIdLineHeight] :: FormattedTextId -> Maybe NumberOrNormal

-- | <i>dir</i> attribute
[formattedTextIdDir] :: FormattedTextId -> Maybe TextDirection

-- | <i>enclosure</i> attribute
[formattedTextIdEnclosure] :: FormattedTextId -> Maybe EnclosureShape

-- | <i>id</i> attribute
[formattedTextIdId] :: FormattedTextId -> Maybe ID
parseFormattedTextId :: XParse FormattedTextId

-- | Smart constructor for <a>FormattedTextId</a>
mkFormattedTextId :: String -> FormattedTextId

-- | <tt>forward</tt> <i>(complex)</i>
--   
--   The backup and forward elements are required to coordinate multiple
--   voices in one part, including music on multiple staves. The forward
--   element is generally used within voices and staves. Duration values
--   should always be positive, and should not cross measure boundaries or
--   mid-measure changes in the divisions value.
data Forward
Forward :: Duration -> EditorialVoice -> Maybe Staff -> Forward
[forwardDuration] :: Forward -> Duration
[forwardEditorialVoice] :: Forward -> EditorialVoice
[forwardStaff] :: Forward -> Maybe Staff
parseForward :: XParse Forward

-- | Smart constructor for <a>Forward</a>
mkForward :: Duration -> EditorialVoice -> Forward

-- | <tt>frame</tt> <i>(complex)</i>
--   
--   The frame type represents a frame or fretboard diagram used together
--   with a chord symbol. The representation is based on the NIFF guitar
--   grid with additional information. The frame type's unplayed attribute
--   indicates what to display above a string that has no associated
--   frame-note element. Typical values are x and the empty string. If the
--   attribute is not present, the display of the unplayed string is
--   application-defined.
data Frame
Frame :: Maybe Tenths -> Maybe Tenths -> Maybe Token -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Color -> Maybe LeftCenterRight -> Maybe ValignImage -> Maybe ID -> PositiveInteger -> PositiveInteger -> Maybe FirstFret -> [FrameNote] -> Frame

-- | <i>height</i> attribute
[frameHeight] :: Frame -> Maybe Tenths

-- | <i>width</i> attribute
[frameWidth] :: Frame -> Maybe Tenths

-- | <i>unplayed</i> attribute
[frameUnplayed] :: Frame -> Maybe Token

-- | <i>default-x</i> attribute
[frameDefaultX] :: Frame -> Maybe Tenths

-- | <i>default-y</i> attribute
[frameDefaultY] :: Frame -> Maybe Tenths

-- | <i>relative-x</i> attribute
[frameRelativeX] :: Frame -> Maybe Tenths

-- | <i>relative-y</i> attribute
[frameRelativeY] :: Frame -> Maybe Tenths

-- | <i>color</i> attribute
[frameColor] :: Frame -> Maybe Color

-- | <i>halign</i> attribute
[frameHalign] :: Frame -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[frameValign] :: Frame -> Maybe ValignImage

-- | <i>id</i> attribute
[frameId] :: Frame -> Maybe ID

-- | <i>frame-strings</i> child element
[frameFrameStrings] :: Frame -> PositiveInteger

-- | <i>frame-frets</i> child element
[frameFrameFrets] :: Frame -> PositiveInteger

-- | <i>first-fret</i> child element
[frameFirstFret] :: Frame -> Maybe FirstFret

-- | <i>frame-note</i> child element
[frameFrameNote] :: Frame -> [FrameNote]
parseFrame :: XParse Frame

-- | Smart constructor for <a>Frame</a>
mkFrame :: PositiveInteger -> PositiveInteger -> Frame

-- | <tt>frame-note</tt> <i>(complex)</i>
--   
--   The frame-note type represents each note included in the frame. An
--   open string will have a fret value of 0, while a muted string will not
--   be associated with a frame-note element.
data FrameNote
FrameNote :: CmpString -> Fret -> Maybe Fingering -> Maybe Barre -> FrameNote

-- | <i>string</i> child element
[frameNoteString] :: FrameNote -> CmpString

-- | <i>fret</i> child element
[frameNoteFret] :: FrameNote -> Fret

-- | <i>fingering</i> child element
[frameNoteFingering] :: FrameNote -> Maybe Fingering

-- | <i>barre</i> child element
[frameNoteBarre] :: FrameNote -> Maybe Barre
parseFrameNote :: XParse FrameNote

-- | Smart constructor for <a>FrameNote</a>
mkFrameNote :: CmpString -> Fret -> FrameNote

-- | <tt>fret</tt> <i>(complex)</i>
--   
--   The fret element is used with tablature notation and chord diagrams.
--   Fret numbers start with 0 for an open string and 1 for the first fret.
data Fret
Fret :: NonNegativeInteger -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Fret

-- | text content
[fretNonNegativeInteger] :: Fret -> NonNegativeInteger

-- | <i>font-family</i> attribute
[fretFontFamily] :: Fret -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[fretFontStyle] :: Fret -> Maybe FontStyle

-- | <i>font-size</i> attribute
[fretFontSize] :: Fret -> Maybe FontSize

-- | <i>font-weight</i> attribute
[fretFontWeight] :: Fret -> Maybe FontWeight

-- | <i>color</i> attribute
[fretColor] :: Fret -> Maybe Color
parseFret :: XParse Fret

-- | Smart constructor for <a>Fret</a>
mkFret :: NonNegativeInteger -> Fret

-- | <tt>glass</tt> <i>(complex)</i>
--   
--   The glass type represents pictograms for glass percussion instruments.
--   The smufl attribute is used to distinguish different SMuFL glyphs for
--   wind chimes in the chimes pictograms range, including those made of
--   materials other than glass.
data Glass
Glass :: GlassValue -> Maybe SmuflPictogramGlyphName -> Glass

-- | text content
[glassGlassValue] :: Glass -> GlassValue

-- | <i>smufl</i> attribute
[glassSmufl] :: Glass -> Maybe SmuflPictogramGlyphName
parseGlass :: XParse Glass

-- | Smart constructor for <a>Glass</a>
mkGlass :: GlassValue -> Glass

-- | <tt>glissando</tt> <i>(complex)</i>
--   
--   Glissando and slide types both indicate rapidly moving from one pitch
--   to the other so that individual notes are not discerned. The
--   distinction is similar to that between NIFF's glissando and portamento
--   elements. A glissando sounds the half notes in between the slide and
--   defaults to a wavy line. The optional text is printed alongside the
--   line.
data Glissando
Glissando :: String -> StartStop -> Maybe NumberLevel -> Maybe LineType -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe ID -> Glissando

-- | text content
[glissandoString] :: Glissando -> String

-- | <i>type</i> attribute
[glissandoType] :: Glissando -> StartStop

-- | <i>number</i> attribute
[glissandoNumber] :: Glissando -> Maybe NumberLevel

-- | <i>line-type</i> attribute
[glissandoLineType] :: Glissando -> Maybe LineType

-- | <i>dash-length</i> attribute
[glissandoDashLength] :: Glissando -> Maybe Tenths

-- | <i>space-length</i> attribute
[glissandoSpaceLength] :: Glissando -> Maybe Tenths

-- | <i>default-x</i> attribute
[glissandoDefaultX] :: Glissando -> Maybe Tenths

-- | <i>default-y</i> attribute
[glissandoDefaultY] :: Glissando -> Maybe Tenths

-- | <i>relative-x</i> attribute
[glissandoRelativeX] :: Glissando -> Maybe Tenths

-- | <i>relative-y</i> attribute
[glissandoRelativeY] :: Glissando -> Maybe Tenths

-- | <i>font-family</i> attribute
[glissandoFontFamily] :: Glissando -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[glissandoFontStyle] :: Glissando -> Maybe FontStyle

-- | <i>font-size</i> attribute
[glissandoFontSize] :: Glissando -> Maybe FontSize

-- | <i>font-weight</i> attribute
[glissandoFontWeight] :: Glissando -> Maybe FontWeight

-- | <i>color</i> attribute
[glissandoColor] :: Glissando -> Maybe Color

-- | <i>id</i> attribute
[glissandoId] :: Glissando -> Maybe ID
parseGlissando :: XParse Glissando

-- | Smart constructor for <a>Glissando</a>
mkGlissando :: String -> StartStop -> Glissando

-- | <tt>glyph</tt> <i>(complex)</i>
--   
--   The glyph element represents what SMuFL glyph should be used for
--   different variations of symbols that are semantically identical. The
--   type attribute specifies what type of glyph is being defined. The
--   element value specifies what SMuFL glyph to use, including recommended
--   stylistic alternates. The SMuFL glyph name should match the type. For
--   instance, a type of quarter-rest would use values restQuarter,
--   restQuarterOld, or restQuarterZ. A type of g-clef-ottava-bassa would
--   use values gClef8vb, gClef8vbOld, or gClef8vbCClef. A type of
--   octave-shift-up-8 would use values ottava, ottavaBassa, ottavaBassaBa,
--   ottavaBassaVb, or octaveBassa.
data Glyph
Glyph :: SmuflGlyphName -> GlyphType -> Glyph

-- | text content
[glyphSmuflGlyphName] :: Glyph -> SmuflGlyphName

-- | <i>type</i> attribute
[cmpglyphType] :: Glyph -> GlyphType
parseGlyph :: XParse Glyph

-- | Smart constructor for <a>Glyph</a>
mkGlyph :: SmuflGlyphName -> GlyphType -> Glyph

-- | <tt>grace</tt> <i>(complex)</i>
--   
--   The grace type indicates the presence of a grace note. The slash
--   attribute for a grace note is yes for slashed eighth notes. The other
--   grace note attributes come from MuseData sound suggestions. The
--   steal-time-previous attribute indicates the percentage of time to
--   steal from the previous note for the grace note. The
--   steal-time-following attribute indicates the percentage of time to
--   steal from the following note for the grace note, as for
--   appoggiaturas. The make-time attribute indicates to make time, not
--   steal time; the units are in real-time divisions for the grace note.
data Grace
Grace :: Maybe Percent -> Maybe Percent -> Maybe Divisions -> Maybe YesNo -> Grace

-- | <i>steal-time-previous</i> attribute
[graceStealTimePrevious] :: Grace -> Maybe Percent

-- | <i>steal-time-following</i> attribute
[graceStealTimeFollowing] :: Grace -> Maybe Percent

-- | <i>make-time</i> attribute
[graceMakeTime] :: Grace -> Maybe Divisions

-- | <i>slash</i> attribute
[graceSlash] :: Grace -> Maybe YesNo
parseGrace :: XParse Grace

-- | Smart constructor for <a>Grace</a>
mkGrace :: Grace

-- | <tt>group-barline</tt> <i>(complex)</i>
--   
--   The group-barline type indicates if the group should have common
--   barlines.
data GroupBarline
GroupBarline :: GroupBarlineValue -> Maybe Color -> GroupBarline

-- | text content
[groupBarlineGroupBarlineValue] :: GroupBarline -> GroupBarlineValue

-- | <i>color</i> attribute
[groupBarlineColor] :: GroupBarline -> Maybe Color
parseGroupBarline :: XParse GroupBarline

-- | Smart constructor for <a>GroupBarline</a>
mkGroupBarline :: GroupBarlineValue -> GroupBarline

-- | <tt>group-name</tt> <i>(complex)</i>
--   
--   The group-name type describes the name or abbreviation of a part-group
--   element. Formatting attributes in the group-name type are deprecated
--   in Version 2.0 in favor of the new group-name-display and
--   group-abbreviation-display elements.
data GroupName
GroupName :: String -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> GroupName

-- | text content
[groupNameString] :: GroupName -> String

-- | <i>default-x</i> attribute
[groupNameDefaultX] :: GroupName -> Maybe Tenths

-- | <i>default-y</i> attribute
[groupNameDefaultY] :: GroupName -> Maybe Tenths

-- | <i>relative-x</i> attribute
[groupNameRelativeX] :: GroupName -> Maybe Tenths

-- | <i>relative-y</i> attribute
[groupNameRelativeY] :: GroupName -> Maybe Tenths

-- | <i>font-family</i> attribute
[groupNameFontFamily] :: GroupName -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[groupNameFontStyle] :: GroupName -> Maybe FontStyle

-- | <i>font-size</i> attribute
[groupNameFontSize] :: GroupName -> Maybe FontSize

-- | <i>font-weight</i> attribute
[groupNameFontWeight] :: GroupName -> Maybe FontWeight

-- | <i>color</i> attribute
[groupNameColor] :: GroupName -> Maybe Color

-- | <i>justify</i> attribute
[groupNameJustify] :: GroupName -> Maybe LeftCenterRight
parseGroupName :: XParse GroupName

-- | Smart constructor for <a>GroupName</a>
mkGroupName :: String -> GroupName

-- | <tt>group-symbol</tt> <i>(complex)</i>
--   
--   The group-symbol type indicates how the symbol for a group is
--   indicated in the score.
data GroupSymbol
GroupSymbol :: GroupSymbolValue -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Color -> GroupSymbol

-- | text content
[groupSymbolGroupSymbolValue] :: GroupSymbol -> GroupSymbolValue

-- | <i>default-x</i> attribute
[groupSymbolDefaultX] :: GroupSymbol -> Maybe Tenths

-- | <i>default-y</i> attribute
[groupSymbolDefaultY] :: GroupSymbol -> Maybe Tenths

-- | <i>relative-x</i> attribute
[groupSymbolRelativeX] :: GroupSymbol -> Maybe Tenths

-- | <i>relative-y</i> attribute
[groupSymbolRelativeY] :: GroupSymbol -> Maybe Tenths

-- | <i>color</i> attribute
[groupSymbolColor] :: GroupSymbol -> Maybe Color
parseGroupSymbol :: XParse GroupSymbol

-- | Smart constructor for <a>GroupSymbol</a>
mkGroupSymbol :: GroupSymbolValue -> GroupSymbol

-- | <tt>grouping</tt> <i>(complex)</i>
--   
--   The grouping type is used for musical analysis. When the type
--   attribute is "start" or "single", it usually contains one or more
--   feature elements. The number attribute is used for distinguishing
--   between overlapping and hierarchical groupings. The member-of
--   attribute allows for easy distinguishing of what grouping elements are
--   in what hierarchy. Feature elements contained within a "stop" type of
--   grouping may be ignored.
--   
--   This element is flexible to allow for different types of analyses.
--   Future versions of the MusicXML format may add elements that can
--   represent more standardized categories of analysis data, allowing for
--   easier data sharing.
data Grouping
Grouping :: StartStopSingle -> Maybe Token -> Maybe Token -> Maybe ID -> [Feature] -> Grouping

-- | <i>type</i> attribute
[groupingType] :: Grouping -> StartStopSingle

-- | <i>number</i> attribute
[groupingNumber] :: Grouping -> Maybe Token

-- | <i>member-of</i> attribute
[groupingMemberOf] :: Grouping -> Maybe Token

-- | <i>id</i> attribute
[groupingId] :: Grouping -> Maybe ID

-- | <i>feature</i> child element
[groupingFeature] :: Grouping -> [Feature]
parseGrouping :: XParse Grouping

-- | Smart constructor for <a>Grouping</a>
mkGrouping :: StartStopSingle -> Grouping

-- | <tt>hammer-on-pull-off</tt> <i>(complex)</i>
--   
--   The hammer-on and pull-off elements are used in guitar and fretted
--   instrument notation. Since a single slur can be marked over many
--   notes, the hammer-on and pull-off elements are separate so the
--   individual pair of notes can be specified. The element content can be
--   used to specify how the hammer-on or pull-off should be notated. An
--   empty element leaves this choice up to the application.
data HammerOnPullOff
HammerOnPullOff :: String -> StartStop -> Maybe NumberLevel -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> HammerOnPullOff

-- | text content
[hammerOnPullOffString] :: HammerOnPullOff -> String

-- | <i>type</i> attribute
[hammerOnPullOffType] :: HammerOnPullOff -> StartStop

-- | <i>number</i> attribute
[hammerOnPullOffNumber] :: HammerOnPullOff -> Maybe NumberLevel

-- | <i>default-x</i> attribute
[hammerOnPullOffDefaultX] :: HammerOnPullOff -> Maybe Tenths

-- | <i>default-y</i> attribute
[hammerOnPullOffDefaultY] :: HammerOnPullOff -> Maybe Tenths

-- | <i>relative-x</i> attribute
[hammerOnPullOffRelativeX] :: HammerOnPullOff -> Maybe Tenths

-- | <i>relative-y</i> attribute
[hammerOnPullOffRelativeY] :: HammerOnPullOff -> Maybe Tenths

-- | <i>font-family</i> attribute
[hammerOnPullOffFontFamily] :: HammerOnPullOff -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[hammerOnPullOffFontStyle] :: HammerOnPullOff -> Maybe FontStyle

-- | <i>font-size</i> attribute
[hammerOnPullOffFontSize] :: HammerOnPullOff -> Maybe FontSize

-- | <i>font-weight</i> attribute
[hammerOnPullOffFontWeight] :: HammerOnPullOff -> Maybe FontWeight

-- | <i>color</i> attribute
[hammerOnPullOffColor] :: HammerOnPullOff -> Maybe Color

-- | <i>placement</i> attribute
[hammerOnPullOffPlacement] :: HammerOnPullOff -> Maybe AboveBelow
parseHammerOnPullOff :: XParse HammerOnPullOff

-- | Smart constructor for <a>HammerOnPullOff</a>
mkHammerOnPullOff :: String -> StartStop -> HammerOnPullOff

-- | <tt>handbell</tt> <i>(complex)</i>
--   
--   The handbell element represents notation for various techniques used
--   in handbell and handchime music.
data Handbell
Handbell :: HandbellValue -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Handbell

-- | text content
[handbellHandbellValue] :: Handbell -> HandbellValue

-- | <i>default-x</i> attribute
[handbellDefaultX] :: Handbell -> Maybe Tenths

-- | <i>default-y</i> attribute
[handbellDefaultY] :: Handbell -> Maybe Tenths

-- | <i>relative-x</i> attribute
[handbellRelativeX] :: Handbell -> Maybe Tenths

-- | <i>relative-y</i> attribute
[handbellRelativeY] :: Handbell -> Maybe Tenths

-- | <i>font-family</i> attribute
[handbellFontFamily] :: Handbell -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[handbellFontStyle] :: Handbell -> Maybe FontStyle

-- | <i>font-size</i> attribute
[handbellFontSize] :: Handbell -> Maybe FontSize

-- | <i>font-weight</i> attribute
[handbellFontWeight] :: Handbell -> Maybe FontWeight

-- | <i>color</i> attribute
[handbellColor] :: Handbell -> Maybe Color

-- | <i>placement</i> attribute
[handbellPlacement] :: Handbell -> Maybe AboveBelow
parseHandbell :: XParse Handbell

-- | Smart constructor for <a>Handbell</a>
mkHandbell :: HandbellValue -> Handbell

-- | <tt>harmon-closed</tt> <i>(complex)</i>
--   
--   The harmon-closed type represents whether the harmon mute is closed,
--   open, or half-open. The optional location attribute indicates which
--   portion of the symbol is filled in when the element value is half.
data HarmonClosed
HarmonClosed :: HarmonClosedValue -> Maybe HarmonClosedLocation -> HarmonClosed

-- | text content
[harmonClosedHarmonClosedValue] :: HarmonClosed -> HarmonClosedValue

-- | <i>location</i> attribute
[harmonClosedLocation] :: HarmonClosed -> Maybe HarmonClosedLocation
parseHarmonClosed :: XParse HarmonClosed

-- | Smart constructor for <a>HarmonClosed</a>
mkHarmonClosed :: HarmonClosedValue -> HarmonClosed

-- | <tt>harmon-mute</tt> <i>(complex)</i>
--   
--   The harmon-mute type represents the symbols used for harmon mutes in
--   brass notation.
data HarmonMute
HarmonMute :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> HarmonClosed -> HarmonMute

-- | <i>default-x</i> attribute
[harmonMuteDefaultX] :: HarmonMute -> Maybe Tenths

-- | <i>default-y</i> attribute
[harmonMuteDefaultY] :: HarmonMute -> Maybe Tenths

-- | <i>relative-x</i> attribute
[harmonMuteRelativeX] :: HarmonMute -> Maybe Tenths

-- | <i>relative-y</i> attribute
[harmonMuteRelativeY] :: HarmonMute -> Maybe Tenths

-- | <i>font-family</i> attribute
[harmonMuteFontFamily] :: HarmonMute -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[harmonMuteFontStyle] :: HarmonMute -> Maybe FontStyle

-- | <i>font-size</i> attribute
[harmonMuteFontSize] :: HarmonMute -> Maybe FontSize

-- | <i>font-weight</i> attribute
[harmonMuteFontWeight] :: HarmonMute -> Maybe FontWeight

-- | <i>color</i> attribute
[harmonMuteColor] :: HarmonMute -> Maybe Color

-- | <i>placement</i> attribute
[harmonMutePlacement] :: HarmonMute -> Maybe AboveBelow

-- | <i>harmon-closed</i> child element
[harmonMuteHarmonClosed] :: HarmonMute -> HarmonClosed
parseHarmonMute :: XParse HarmonMute

-- | Smart constructor for <a>HarmonMute</a>
mkHarmonMute :: HarmonClosed -> HarmonMute

-- | <tt>harmonic</tt> <i>(complex)</i>
--   
--   The harmonic type indicates natural and artificial harmonics. Allowing
--   the type of pitch to be specified, combined with controls for
--   appearance/playback differences, allows both the notation and the
--   sound to be represented. Artificial harmonics can add a notated
--   touching-pitch; artificial pinch harmonics will usually not notate a
--   touching pitch. The attributes for the harmonic element refer to the
--   use of the circular harmonic symbol, typically but not always used
--   with natural harmonics.
data Harmonic
Harmonic :: Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe ChxHarmonic -> Maybe ChxHarmonic1 -> Harmonic

-- | <i>print-object</i> attribute
[harmonicPrintObject] :: Harmonic -> Maybe YesNo

-- | <i>default-x</i> attribute
[harmonicDefaultX] :: Harmonic -> Maybe Tenths

-- | <i>default-y</i> attribute
[harmonicDefaultY] :: Harmonic -> Maybe Tenths

-- | <i>relative-x</i> attribute
[harmonicRelativeX] :: Harmonic -> Maybe Tenths

-- | <i>relative-y</i> attribute
[harmonicRelativeY] :: Harmonic -> Maybe Tenths

-- | <i>font-family</i> attribute
[harmonicFontFamily] :: Harmonic -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[harmonicFontStyle] :: Harmonic -> Maybe FontStyle

-- | <i>font-size</i> attribute
[harmonicFontSize] :: Harmonic -> Maybe FontSize

-- | <i>font-weight</i> attribute
[harmonicFontWeight] :: Harmonic -> Maybe FontWeight

-- | <i>color</i> attribute
[harmonicColor] :: Harmonic -> Maybe Color

-- | <i>placement</i> attribute
[harmonicPlacement] :: Harmonic -> Maybe AboveBelow
[harmonicHarmonic] :: Harmonic -> Maybe ChxHarmonic
[harmonicHarmonic1] :: Harmonic -> Maybe ChxHarmonic1
parseHarmonic :: XParse Harmonic

-- | Smart constructor for <a>Harmonic</a>
mkHarmonic :: Harmonic

-- | <tt>harmony</tt> <i>(complex)</i>
--   
--   The harmony type is based on Humdrum's **harm encoding, extended to
--   support chord symbols in popular music as well as functional harmony
--   analysis in classical music.
--   
--   If there are alternate harmonies possible, this can be specified using
--   multiple harmony elements differentiated by type. Explicit harmonies
--   have all note present in the music; implied have some notes missing
--   but implied; alternate represents alternate analyses.
--   
--   The harmony object may be used for analysis or for chord symbols. The
--   print-object attribute controls whether or not anything is printed due
--   to the harmony element. The print-frame attribute controls printing of
--   a frame or fretboard diagram. The print-style attribute group sets the
--   default for the harmony, but individual elements can override this
--   with their own print-style values.
data Harmony
Harmony :: Maybe HarmonyType -> Maybe YesNo -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe ID -> [HarmonyChord] -> Maybe Frame -> Maybe Offset -> Editorial -> Maybe Staff -> Harmony

-- | <i>type</i> attribute
[harmonyType] :: Harmony -> Maybe HarmonyType

-- | <i>print-frame</i> attribute
[harmonyPrintFrame] :: Harmony -> Maybe YesNo

-- | <i>print-object</i> attribute
[harmonyPrintObject] :: Harmony -> Maybe YesNo

-- | <i>default-x</i> attribute
[harmonyDefaultX] :: Harmony -> Maybe Tenths

-- | <i>default-y</i> attribute
[harmonyDefaultY] :: Harmony -> Maybe Tenths

-- | <i>relative-x</i> attribute
[harmonyRelativeX] :: Harmony -> Maybe Tenths

-- | <i>relative-y</i> attribute
[harmonyRelativeY] :: Harmony -> Maybe Tenths

-- | <i>font-family</i> attribute
[harmonyFontFamily] :: Harmony -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[harmonyFontStyle] :: Harmony -> Maybe FontStyle

-- | <i>font-size</i> attribute
[harmonyFontSize] :: Harmony -> Maybe FontSize

-- | <i>font-weight</i> attribute
[harmonyFontWeight] :: Harmony -> Maybe FontWeight

-- | <i>color</i> attribute
[harmonyColor] :: Harmony -> Maybe Color

-- | <i>placement</i> attribute
[harmonyPlacement] :: Harmony -> Maybe AboveBelow

-- | <i>id</i> attribute
[harmonyId] :: Harmony -> Maybe ID
[harmonyHarmonyChord] :: Harmony -> [HarmonyChord]

-- | <i>frame</i> child element
[harmonyFrame] :: Harmony -> Maybe Frame

-- | <i>offset</i> child element
[harmonyOffset] :: Harmony -> Maybe Offset
[harmonyEditorial] :: Harmony -> Editorial
[harmonyStaff] :: Harmony -> Maybe Staff
parseHarmony :: XParse Harmony

-- | Smart constructor for <a>Harmony</a>
mkHarmony :: Editorial -> Harmony

-- | <tt>harp-pedals</tt> <i>(complex)</i>
--   
--   The harp-pedals type is used to create harp pedal diagrams. The
--   pedal-step and pedal-alter elements use the same values as the step
--   and alter elements. For easiest reading, the pedal-tuning elements
--   should follow standard harp pedal order, with pedal-step values of D,
--   C, B, E, F, G, and A.
data HarpPedals
HarpPedals :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> [PedalTuning] -> HarpPedals

-- | <i>default-x</i> attribute
[harpPedalsDefaultX] :: HarpPedals -> Maybe Tenths

-- | <i>default-y</i> attribute
[harpPedalsDefaultY] :: HarpPedals -> Maybe Tenths

-- | <i>relative-x</i> attribute
[harpPedalsRelativeX] :: HarpPedals -> Maybe Tenths

-- | <i>relative-y</i> attribute
[harpPedalsRelativeY] :: HarpPedals -> Maybe Tenths

-- | <i>font-family</i> attribute
[harpPedalsFontFamily] :: HarpPedals -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[harpPedalsFontStyle] :: HarpPedals -> Maybe FontStyle

-- | <i>font-size</i> attribute
[harpPedalsFontSize] :: HarpPedals -> Maybe FontSize

-- | <i>font-weight</i> attribute
[harpPedalsFontWeight] :: HarpPedals -> Maybe FontWeight

-- | <i>color</i> attribute
[harpPedalsColor] :: HarpPedals -> Maybe Color

-- | <i>halign</i> attribute
[harpPedalsHalign] :: HarpPedals -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[harpPedalsValign] :: HarpPedals -> Maybe Valign

-- | <i>id</i> attribute
[harpPedalsId] :: HarpPedals -> Maybe ID

-- | <i>pedal-tuning</i> child element
[harpPedalsPedalTuning] :: HarpPedals -> [PedalTuning]
parseHarpPedals :: XParse HarpPedals

-- | Smart constructor for <a>HarpPedals</a>
mkHarpPedals :: HarpPedals

-- | <tt>heel-toe</tt> <i>(complex)</i>
--   
--   The heel and toe elements are used with organ pedals. The substitution
--   value is "no" if the attribute is not present.
data HeelToe
HeelToe :: HeelToe -> Maybe YesNo -> HeelToe
[heelToeEmptyPlacement] :: HeelToe -> HeelToe

-- | <i>substitution</i> attribute
[heelToeSubstitution] :: HeelToe -> Maybe YesNo
parseHeelToe :: XParse HeelToe

-- | Smart constructor for <a>HeelToe</a>
mkHeelToe :: HeelToe -> HeelToe

-- | <tt>hole</tt> <i>(complex)</i>
--   
--   The hole type represents the symbols used for woodwind and brass
--   fingerings as well as other notations.
data Hole
Hole :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe String -> HoleClosed -> Maybe String -> Hole

-- | <i>default-x</i> attribute
[holeDefaultX] :: Hole -> Maybe Tenths

-- | <i>default-y</i> attribute
[holeDefaultY] :: Hole -> Maybe Tenths

-- | <i>relative-x</i> attribute
[holeRelativeX] :: Hole -> Maybe Tenths

-- | <i>relative-y</i> attribute
[holeRelativeY] :: Hole -> Maybe Tenths

-- | <i>font-family</i> attribute
[holeFontFamily] :: Hole -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[holeFontStyle] :: Hole -> Maybe FontStyle

-- | <i>font-size</i> attribute
[holeFontSize] :: Hole -> Maybe FontSize

-- | <i>font-weight</i> attribute
[holeFontWeight] :: Hole -> Maybe FontWeight

-- | <i>color</i> attribute
[holeColor] :: Hole -> Maybe Color

-- | <i>placement</i> attribute
[holePlacement] :: Hole -> Maybe AboveBelow

-- | <i>hole-type</i> child element
[holeHoleType] :: Hole -> Maybe String

-- | <i>hole-closed</i> child element
[holeHoleClosed] :: Hole -> HoleClosed

-- | <i>hole-shape</i> child element
[holeHoleShape] :: Hole -> Maybe String
parseHole :: XParse Hole

-- | Smart constructor for <a>Hole</a>
mkHole :: HoleClosed -> Hole

-- | <tt>hole-closed</tt> <i>(complex)</i>
--   
--   The hole-closed type represents whether the hole is closed, open, or
--   half-open. The optional location attribute indicates which portion of
--   the hole is filled in when the element value is half.
data HoleClosed
HoleClosed :: HoleClosedValue -> Maybe HoleClosedLocation -> HoleClosed

-- | text content
[holeClosedHoleClosedValue] :: HoleClosed -> HoleClosedValue

-- | <i>location</i> attribute
[holeClosedLocation] :: HoleClosed -> Maybe HoleClosedLocation
parseHoleClosed :: XParse HoleClosed

-- | Smart constructor for <a>HoleClosed</a>
mkHoleClosed :: HoleClosedValue -> HoleClosed

-- | <tt>horizontal-turn</tt> <i>(complex)</i>
--   
--   The horizontal-turn type represents turn elements that are horizontal
--   rather than vertical. These are empty elements with print-style,
--   placement, trill-sound, and slash attributes. If the slash attribute
--   is yes, then a vertical line is used to slash the turn; it is no by
--   default.
data HorizontalTurn
HorizontalTurn :: Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe StartNote -> Maybe TrillStep -> Maybe TwoNoteTurn -> Maybe YesNo -> Maybe TrillBeats -> Maybe Percent -> Maybe Percent -> HorizontalTurn

-- | <i>slash</i> attribute
[horizontalTurnSlash] :: HorizontalTurn -> Maybe YesNo

-- | <i>default-x</i> attribute
[horizontalTurnDefaultX] :: HorizontalTurn -> Maybe Tenths

-- | <i>default-y</i> attribute
[horizontalTurnDefaultY] :: HorizontalTurn -> Maybe Tenths

-- | <i>relative-x</i> attribute
[horizontalTurnRelativeX] :: HorizontalTurn -> Maybe Tenths

-- | <i>relative-y</i> attribute
[horizontalTurnRelativeY] :: HorizontalTurn -> Maybe Tenths

-- | <i>font-family</i> attribute
[horizontalTurnFontFamily] :: HorizontalTurn -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[horizontalTurnFontStyle] :: HorizontalTurn -> Maybe FontStyle

-- | <i>font-size</i> attribute
[horizontalTurnFontSize] :: HorizontalTurn -> Maybe FontSize

-- | <i>font-weight</i> attribute
[horizontalTurnFontWeight] :: HorizontalTurn -> Maybe FontWeight

-- | <i>color</i> attribute
[horizontalTurnColor] :: HorizontalTurn -> Maybe Color

-- | <i>placement</i> attribute
[horizontalTurnPlacement] :: HorizontalTurn -> Maybe AboveBelow

-- | <i>start-note</i> attribute
[horizontalTurnStartNote] :: HorizontalTurn -> Maybe StartNote

-- | <i>trill-step</i> attribute
[horizontalTurnTrillStep] :: HorizontalTurn -> Maybe TrillStep

-- | <i>two-note-turn</i> attribute
[horizontalTurnTwoNoteTurn] :: HorizontalTurn -> Maybe TwoNoteTurn

-- | <i>accelerate</i> attribute
[horizontalTurnAccelerate] :: HorizontalTurn -> Maybe YesNo

-- | <i>beats</i> attribute
[horizontalTurnBeats] :: HorizontalTurn -> Maybe TrillBeats

-- | <i>second-beat</i> attribute
[horizontalTurnSecondBeat] :: HorizontalTurn -> Maybe Percent

-- | <i>last-beat</i> attribute
[horizontalTurnLastBeat] :: HorizontalTurn -> Maybe Percent
parseHorizontalTurn :: XParse HorizontalTurn

-- | Smart constructor for <a>HorizontalTurn</a>
mkHorizontalTurn :: HorizontalTurn

-- | <tt>identification</tt> <i>(complex)</i>
--   
--   Identification contains basic metadata about the score. It includes
--   the information in MuseData headers that may apply at a score-wide,
--   movement-wide, or part-wide level. The creator, rights, source, and
--   relation elements are based on Dublin Core.
data Identification
Identification :: [TypedText] -> [TypedText] -> Maybe Encoding -> Maybe String -> [TypedText] -> Maybe Miscellaneous -> Identification

-- | <i>creator</i> child element
[identificationCreator] :: Identification -> [TypedText]

-- | <i>rights</i> child element
[identificationRights] :: Identification -> [TypedText]

-- | <i>encoding</i> child element
[identificationEncoding] :: Identification -> Maybe Encoding

-- | <i>source</i> child element
[identificationSource] :: Identification -> Maybe String

-- | <i>relation</i> child element
[identificationRelation] :: Identification -> [TypedText]

-- | <i>miscellaneous</i> child element
[identificationMiscellaneous] :: Identification -> Maybe Miscellaneous
parseIdentification :: XParse Identification

-- | Smart constructor for <a>Identification</a>
mkIdentification :: Identification

-- | <tt>image</tt> <i>(complex)</i>
--   
--   The image type is used to include graphical images in a score.
data Image
Image :: String -> Token -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe LeftCenterRight -> Maybe ValignImage -> Maybe ID -> Image

-- | <i>source</i> attribute
[imageSource] :: Image -> String

-- | <i>type</i> attribute
[imageType] :: Image -> Token

-- | <i>height</i> attribute
[imageHeight] :: Image -> Maybe Tenths

-- | <i>width</i> attribute
[imageWidth] :: Image -> Maybe Tenths

-- | <i>default-x</i> attribute
[imageDefaultX] :: Image -> Maybe Tenths

-- | <i>default-y</i> attribute
[imageDefaultY] :: Image -> Maybe Tenths

-- | <i>relative-x</i> attribute
[imageRelativeX] :: Image -> Maybe Tenths

-- | <i>relative-y</i> attribute
[imageRelativeY] :: Image -> Maybe Tenths

-- | <i>halign</i> attribute
[imageHalign] :: Image -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[imageValign] :: Image -> Maybe ValignImage

-- | <i>id</i> attribute
[imageId] :: Image -> Maybe ID
parseImage :: XParse Image

-- | Smart constructor for <a>Image</a>
mkImage :: String -> Token -> Image

-- | <tt>instrument</tt> <i>(complex)</i>
--   
--   The instrument type distinguishes between score-instrument elements in
--   a score-part. The id attribute is an IDREF back to the
--   score-instrument ID. If multiple score-instruments are specified on a
--   score-part, there should be an instrument element for each note in the
--   part.
data Instrument
Instrument :: IDREF -> Instrument

-- | <i>id</i> attribute
[instrumentId] :: Instrument -> IDREF
parseInstrument :: XParse Instrument

-- | Smart constructor for <a>Instrument</a>
mkInstrument :: IDREF -> Instrument

-- | <tt>interchangeable</tt> <i>(complex)</i>
--   
--   The interchangeable type is used to represent the second in a pair of
--   interchangeable dual time signatures, such as the 6<i>8 in 3</i>4
--   (6/8). A separate symbol attribute value is available compared to the
--   time element's symbol attribute, which applies to the first of the
--   dual time signatures.
data Interchangeable
Interchangeable :: Maybe TimeSymbol -> Maybe TimeSeparator -> Maybe TimeRelation -> [TimeSignature] -> Interchangeable

-- | <i>symbol</i> attribute
[interchangeableSymbol] :: Interchangeable -> Maybe TimeSymbol

-- | <i>separator</i> attribute
[interchangeableSeparator] :: Interchangeable -> Maybe TimeSeparator

-- | <i>time-relation</i> child element
[interchangeableTimeRelation] :: Interchangeable -> Maybe TimeRelation
[interchangeableTimeSignature] :: Interchangeable -> [TimeSignature]
parseInterchangeable :: XParse Interchangeable

-- | Smart constructor for <a>Interchangeable</a>
mkInterchangeable :: Interchangeable

-- | <tt>inversion</tt> <i>(complex)</i>
--   
--   The inversion type represents harmony inversions. The value is a
--   number indicating which inversion is used: 0 for root position, 1 for
--   first inversion, etc.
data Inversion
Inversion :: NonNegativeInteger -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Inversion

-- | text content
[inversionNonNegativeInteger] :: Inversion -> NonNegativeInteger

-- | <i>default-x</i> attribute
[inversionDefaultX] :: Inversion -> Maybe Tenths

-- | <i>default-y</i> attribute
[inversionDefaultY] :: Inversion -> Maybe Tenths

-- | <i>relative-x</i> attribute
[inversionRelativeX] :: Inversion -> Maybe Tenths

-- | <i>relative-y</i> attribute
[inversionRelativeY] :: Inversion -> Maybe Tenths

-- | <i>font-family</i> attribute
[inversionFontFamily] :: Inversion -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[inversionFontStyle] :: Inversion -> Maybe FontStyle

-- | <i>font-size</i> attribute
[inversionFontSize] :: Inversion -> Maybe FontSize

-- | <i>font-weight</i> attribute
[inversionFontWeight] :: Inversion -> Maybe FontWeight

-- | <i>color</i> attribute
[inversionColor] :: Inversion -> Maybe Color
parseInversion :: XParse Inversion

-- | Smart constructor for <a>Inversion</a>
mkInversion :: NonNegativeInteger -> Inversion

-- | <tt>key</tt> <i>(complex)</i>
--   
--   The key type represents a key signature. Both traditional and
--   non-traditional key signatures are supported. The optional number
--   attribute refers to staff numbers. If absent, the key signature
--   applies to all staves in the part. Key signatures appear at the start
--   of each system unless the print-object attribute has been set to "no".
data Key
Key :: Maybe StaffNumber -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe YesNo -> Maybe ID -> ChxKey -> [KeyOctave] -> Key

-- | <i>number</i> attribute
[keyNumber] :: Key -> Maybe StaffNumber

-- | <i>default-x</i> attribute
[keyDefaultX] :: Key -> Maybe Tenths

-- | <i>default-y</i> attribute
[keyDefaultY] :: Key -> Maybe Tenths

-- | <i>relative-x</i> attribute
[keyRelativeX] :: Key -> Maybe Tenths

-- | <i>relative-y</i> attribute
[keyRelativeY] :: Key -> Maybe Tenths

-- | <i>font-family</i> attribute
[keyFontFamily] :: Key -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[keyFontStyle] :: Key -> Maybe FontStyle

-- | <i>font-size</i> attribute
[keyFontSize] :: Key -> Maybe FontSize

-- | <i>font-weight</i> attribute
[keyFontWeight] :: Key -> Maybe FontWeight

-- | <i>color</i> attribute
[keyColor] :: Key -> Maybe Color

-- | <i>print-object</i> attribute
[keyPrintObject] :: Key -> Maybe YesNo

-- | <i>id</i> attribute
[keyId] :: Key -> Maybe ID
[keyKey] :: Key -> ChxKey

-- | <i>key-octave</i> child element
[keyKeyOctave] :: Key -> [KeyOctave]
parseKey :: XParse Key

-- | Smart constructor for <a>Key</a>
mkKey :: ChxKey -> Key

-- | <tt>key-accidental</tt> <i>(complex)</i>
--   
--   The key-accidental type indicates the accidental to be displayed in a
--   non-traditional key signature, represented in the same manner as the
--   accidental type without the formatting attributes.
data KeyAccidental
KeyAccidental :: AccidentalValue -> Maybe SmuflAccidentalGlyphName -> KeyAccidental

-- | text content
[keyAccidentalAccidentalValue] :: KeyAccidental -> AccidentalValue

-- | <i>smufl</i> attribute
[keyAccidentalSmufl] :: KeyAccidental -> Maybe SmuflAccidentalGlyphName
parseKeyAccidental :: XParse KeyAccidental

-- | Smart constructor for <a>KeyAccidental</a>
mkKeyAccidental :: AccidentalValue -> KeyAccidental

-- | <tt>key-octave</tt> <i>(complex)</i>
--   
--   The key-octave element specifies in which octave an element of a key
--   signature appears. The content specifies the octave value using the
--   same values as the display-octave element. The number attribute is a
--   positive integer that refers to the key signature element in
--   left-to-right order. If the cancel attribute is set to yes, then this
--   number refers to the canceling key signature specified by the cancel
--   element in the parent key element. The cancel attribute cannot be set
--   to yes if there is no corresponding cancel element within the parent
--   key element. It is no by default.
data KeyOctave
KeyOctave :: Octave -> PositiveInteger -> Maybe YesNo -> KeyOctave

-- | text content
[keyOctaveOctave] :: KeyOctave -> Octave

-- | <i>number</i> attribute
[keyOctaveNumber] :: KeyOctave -> PositiveInteger

-- | <i>cancel</i> attribute
[keyOctaveCancel] :: KeyOctave -> Maybe YesNo
parseKeyOctave :: XParse KeyOctave

-- | Smart constructor for <a>KeyOctave</a>
mkKeyOctave :: Octave -> PositiveInteger -> KeyOctave

-- | <tt>kind</tt> <i>(complex)</i>
--   
--   Kind indicates the type of chord. Degree elements can then add,
--   subtract, or alter from these starting points
--   
--   <pre>
--   The attributes are used to indicate the formatting of the symbol. Since the kind element is the constant in all the harmony-chord groups that can make up a polychord, many formatting attributes are here.
--   
--   The use-symbols attribute is yes if the kind should be represented when possible with harmony symbols rather than letters and numbers. These symbols include:
--   
--   	major: a triangle, like Unicode 25B3
--   	minor: -, like Unicode 002D
--   	augmented: +, like Unicode 002B
--   	diminished: °, like Unicode 00B0
--   	half-diminished: ø, like Unicode 00F8
--   
--   For the major-minor kind, only the minor symbol is used when use-symbols is yes. The major symbol is set using the symbol attribute in the degree-value element. The corresponding degree-alter value will usually be 0 in this case.
--   
--   The text attribute describes how the kind should be spelled in a score. If use-symbols is yes, the value of the text attribute follows the symbol. The stack-degrees attribute is yes if the degree elements should be stacked above each other. The parentheses-degrees attribute is yes if all the degrees should be in parentheses. The bracket-degrees attribute is yes if all the degrees should be in a bracket. If not specified, these values are implementation-specific. The alignment attributes are for the entire harmony-chord group of which this kind element is a part.
--   </pre>
data Kind
Kind :: KindValue -> Maybe YesNo -> Maybe Token -> Maybe YesNo -> Maybe YesNo -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Kind

-- | text content
[kindKindValue] :: Kind -> KindValue

-- | <i>use-symbols</i> attribute
[kindUseSymbols] :: Kind -> Maybe YesNo

-- | <i>text</i> attribute
[kindText] :: Kind -> Maybe Token

-- | <i>stack-degrees</i> attribute
[kindStackDegrees] :: Kind -> Maybe YesNo

-- | <i>parentheses-degrees</i> attribute
[kindParenthesesDegrees] :: Kind -> Maybe YesNo

-- | <i>bracket-degrees</i> attribute
[kindBracketDegrees] :: Kind -> Maybe YesNo

-- | <i>default-x</i> attribute
[kindDefaultX] :: Kind -> Maybe Tenths

-- | <i>default-y</i> attribute
[kindDefaultY] :: Kind -> Maybe Tenths

-- | <i>relative-x</i> attribute
[kindRelativeX] :: Kind -> Maybe Tenths

-- | <i>relative-y</i> attribute
[kindRelativeY] :: Kind -> Maybe Tenths

-- | <i>font-family</i> attribute
[kindFontFamily] :: Kind -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[kindFontStyle] :: Kind -> Maybe FontStyle

-- | <i>font-size</i> attribute
[kindFontSize] :: Kind -> Maybe FontSize

-- | <i>font-weight</i> attribute
[kindFontWeight] :: Kind -> Maybe FontWeight

-- | <i>color</i> attribute
[kindColor] :: Kind -> Maybe Color

-- | <i>halign</i> attribute
[kindHalign] :: Kind -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[kindValign] :: Kind -> Maybe Valign
parseKind :: XParse Kind

-- | Smart constructor for <a>Kind</a>
mkKind :: KindValue -> Kind

-- | <tt>level</tt> <i>(complex)</i>
--   
--   The level type is used to specify editorial information for different
--   MusicXML elements. If the reference attribute for the level element is
--   yes, this indicates editorial information that is for display only and
--   should not affect playback. For instance, a modern edition of older
--   music may set reference="yes" on the attributes containing the music's
--   original clef, key, and time signature. It is no by default.
data Level
Level :: String -> Maybe YesNo -> Maybe YesNo -> Maybe YesNo -> Maybe SymbolSize -> Level

-- | text content
[levelString] :: Level -> String

-- | <i>reference</i> attribute
[levelReference] :: Level -> Maybe YesNo

-- | <i>parentheses</i> attribute
[levelParentheses] :: Level -> Maybe YesNo

-- | <i>bracket</i> attribute
[levelBracket] :: Level -> Maybe YesNo

-- | <i>size</i> attribute
[levelSize] :: Level -> Maybe SymbolSize
parseLevel :: XParse Level

-- | Smart constructor for <a>Level</a>
mkLevel :: String -> Level

-- | <tt>line-width</tt> <i>(complex)</i>
--   
--   The line-width type indicates the width of a line type in tenths. The
--   type attribute defines what type of line is being defined. Values
--   include beam, bracket, dashes, enclosure, ending, extend, heavy
--   barline, leger, light barline, octave shift, pedal, slur middle, slur
--   tip, staff, stem, tie middle, tie tip, tuplet bracket, and wedge. The
--   text content is expressed in tenths.
data LineWidth
LineWidth :: Tenths -> LineWidthType -> LineWidth

-- | text content
[lineWidthTenths] :: LineWidth -> Tenths

-- | <i>type</i> attribute
[cmplineWidthType] :: LineWidth -> LineWidthType
parseLineWidth :: XParse LineWidth

-- | Smart constructor for <a>LineWidth</a>
mkLineWidth :: Tenths -> LineWidthType -> LineWidth

-- | <tt>link</tt> <i>(complex)</i>
--   
--   The link type serves as an outgoing simple XLink. It is also used to
--   connect a MusicXML score with a MusicXML opus. If a relative link is
--   used within a document that is part of a compressed MusicXML file, the
--   link is relative to the root folder of the zip file.
data Link
Link :: Maybe Token -> String -> Maybe Type -> Maybe Token -> Maybe Token -> Maybe SmpShow -> Maybe Actuate -> Maybe NMTOKEN -> Maybe PositiveInteger -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Link

-- | <i>name</i> attribute
[linkName] :: Link -> Maybe Token

-- | <i>xlink:href</i> attribute
[linkHref] :: Link -> String

-- | <i>xlink:type</i> attribute
[linkType] :: Link -> Maybe Type

-- | <i>xlink:role</i> attribute
[linkRole] :: Link -> Maybe Token

-- | <i>xlink:title</i> attribute
[linkTitle] :: Link -> Maybe Token

-- | <i>xlink:show</i> attribute
[linkShow] :: Link -> Maybe SmpShow

-- | <i>xlink:actuate</i> attribute
[linkActuate] :: Link -> Maybe Actuate

-- | <i>element</i> attribute
[linkElement] :: Link -> Maybe NMTOKEN

-- | <i>position</i> attribute
[linkPosition] :: Link -> Maybe PositiveInteger

-- | <i>default-x</i> attribute
[linkDefaultX] :: Link -> Maybe Tenths

-- | <i>default-y</i> attribute
[linkDefaultY] :: Link -> Maybe Tenths

-- | <i>relative-x</i> attribute
[linkRelativeX] :: Link -> Maybe Tenths

-- | <i>relative-y</i> attribute
[linkRelativeY] :: Link -> Maybe Tenths
parseLink :: XParse Link

-- | Smart constructor for <a>Link</a>
mkLink :: String -> Link

-- | <tt>lyric</tt> <i>(complex)</i>
--   
--   The lyric type represents text underlays for lyrics, based on Humdrum
--   with support for other formats. Two text elements that are not
--   separated by an elision element are part of the same syllable, but may
--   have different text formatting. The MusicXML XSD is more strict than
--   the DTD in enforcing this by disallowing a second syllabic element
--   unless preceded by an elision element. The lyric number indicates
--   multiple lines, though a name can be used as well (as in Finale's
--   verse <i> chorus </i> section specification).
--   
--   Justification is center by default; placement is below by default. The
--   print-object attribute can override a note's print-lyric attribute in
--   cases where only some lyrics on a note are printed, as when lyrics for
--   later verses are printed in a block of text rather than with each
--   note. The time-only attribute precisely specifies which lyrics are to
--   be sung which time through a repeated section.
data Lyric
Lyric :: Maybe NMTOKEN -> Maybe Token -> Maybe TimeOnly -> Maybe LeftCenterRight -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe AboveBelow -> Maybe Color -> Maybe YesNo -> Maybe ID -> ChxLyric -> Maybe Empty -> Maybe Empty -> Editorial -> Lyric

-- | <i>number</i> attribute
[lyricNumber] :: Lyric -> Maybe NMTOKEN

-- | <i>name</i> attribute
[lyricName] :: Lyric -> Maybe Token

-- | <i>time-only</i> attribute
[lyricTimeOnly] :: Lyric -> Maybe TimeOnly

-- | <i>justify</i> attribute
[lyricJustify] :: Lyric -> Maybe LeftCenterRight

-- | <i>default-x</i> attribute
[lyricDefaultX] :: Lyric -> Maybe Tenths

-- | <i>default-y</i> attribute
[lyricDefaultY] :: Lyric -> Maybe Tenths

-- | <i>relative-x</i> attribute
[lyricRelativeX] :: Lyric -> Maybe Tenths

-- | <i>relative-y</i> attribute
[lyricRelativeY] :: Lyric -> Maybe Tenths

-- | <i>placement</i> attribute
[lyricPlacement] :: Lyric -> Maybe AboveBelow

-- | <i>color</i> attribute
[lyricColor] :: Lyric -> Maybe Color

-- | <i>print-object</i> attribute
[lyricPrintObject] :: Lyric -> Maybe YesNo

-- | <i>id</i> attribute
[lyricId] :: Lyric -> Maybe ID
[lyricLyric] :: Lyric -> ChxLyric

-- | <i>end-line</i> child element
[lyricEndLine] :: Lyric -> Maybe Empty

-- | <i>end-paragraph</i> child element
[lyricEndParagraph] :: Lyric -> Maybe Empty
[lyricEditorial] :: Lyric -> Editorial
parseLyric :: XParse Lyric

-- | Smart constructor for <a>Lyric</a>
mkLyric :: ChxLyric -> Editorial -> Lyric

-- | <tt>lyric-font</tt> <i>(complex)</i>
--   
--   The lyric-font type specifies the default font for a particular name
--   and number of lyric.
data LyricFont
LyricFont :: Maybe NMTOKEN -> Maybe Token -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> LyricFont

-- | <i>number</i> attribute
[lyricFontNumber] :: LyricFont -> Maybe NMTOKEN

-- | <i>name</i> attribute
[lyricFontName] :: LyricFont -> Maybe Token

-- | <i>font-family</i> attribute
[lyricFontFontFamily] :: LyricFont -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[lyricFontFontStyle] :: LyricFont -> Maybe FontStyle

-- | <i>font-size</i> attribute
[lyricFontFontSize] :: LyricFont -> Maybe FontSize

-- | <i>font-weight</i> attribute
[lyricFontFontWeight] :: LyricFont -> Maybe FontWeight
parseLyricFont :: XParse LyricFont

-- | Smart constructor for <a>LyricFont</a>
mkLyricFont :: LyricFont

-- | <tt>lyric-language</tt> <i>(complex)</i>
--   
--   The lyric-language type specifies the default language for a
--   particular name and number of lyric.
data LyricLanguage
LyricLanguage :: Maybe NMTOKEN -> Maybe Token -> Lang -> LyricLanguage

-- | <i>number</i> attribute
[lyricLanguageNumber] :: LyricLanguage -> Maybe NMTOKEN

-- | <i>name</i> attribute
[lyricLanguageName] :: LyricLanguage -> Maybe Token

-- | <i>xml:lang</i> attribute
[lyricLanguageLang] :: LyricLanguage -> Lang
parseLyricLanguage :: XParse LyricLanguage

-- | Smart constructor for <a>LyricLanguage</a>
mkLyricLanguage :: Lang -> LyricLanguage

-- | <tt>measure</tt> <i>(complex)</i>
data Measure
Measure :: Token -> Maybe MeasureText -> Maybe YesNo -> Maybe YesNo -> Maybe Tenths -> Maybe ID -> MusicData -> Measure

-- | <i>number</i> attribute
[measureNumber] :: Measure -> Token

-- | <i>text</i> attribute
[cmpmeasureText] :: Measure -> Maybe MeasureText

-- | <i>implicit</i> attribute
[measureImplicit] :: Measure -> Maybe YesNo

-- | <i>non-controlling</i> attribute
[measureNonControlling] :: Measure -> Maybe YesNo

-- | <i>width</i> attribute
[measureWidth] :: Measure -> Maybe Tenths

-- | <i>id</i> attribute
[measureId] :: Measure -> Maybe ID
[measureMusicData] :: Measure -> MusicData
parseMeasure :: XParse Measure

-- | Smart constructor for <a>Measure</a>
mkMeasure :: Token -> MusicData -> Measure

-- | <tt>measure</tt> <i>(complex)</i>
data CmpMeasure
CmpMeasure :: Token -> Maybe MeasureText -> Maybe YesNo -> Maybe YesNo -> Maybe Tenths -> Maybe ID -> [Part] -> CmpMeasure

-- | <i>number</i> attribute
[cmpmeasureNumber] :: CmpMeasure -> Token

-- | <i>text</i> attribute
[cmpmeasureText1] :: CmpMeasure -> Maybe MeasureText

-- | <i>implicit</i> attribute
[cmpmeasureImplicit] :: CmpMeasure -> Maybe YesNo

-- | <i>non-controlling</i> attribute
[cmpmeasureNonControlling] :: CmpMeasure -> Maybe YesNo

-- | <i>width</i> attribute
[cmpmeasureWidth] :: CmpMeasure -> Maybe Tenths

-- | <i>id</i> attribute
[cmpmeasureId] :: CmpMeasure -> Maybe ID

-- | <i>part</i> child element
[measurePart] :: CmpMeasure -> [Part]
parseCmpMeasure :: XParse CmpMeasure

-- | Smart constructor for <a>CmpMeasure</a>
mkCmpMeasure :: Token -> CmpMeasure

-- | <tt>measure-layout</tt> <i>(complex)</i>
--   
--   The measure-layout type includes the horizontal distance from the
--   previous measure.
data MeasureLayout
MeasureLayout :: Maybe Tenths -> MeasureLayout

-- | <i>measure-distance</i> child element
[measureLayoutMeasureDistance] :: MeasureLayout -> Maybe Tenths
parseMeasureLayout :: XParse MeasureLayout

-- | Smart constructor for <a>MeasureLayout</a>
mkMeasureLayout :: MeasureLayout

-- | <tt>measure-numbering</tt> <i>(complex)</i>
--   
--   The measure-numbering type describes how frequently measure numbers
--   are displayed on this part. The number attribute from the measure
--   element is used for printing. Measures with an implicit attribute set
--   to "yes" never display a measure number, regardless of the
--   measure-numbering setting.
data MeasureNumbering
MeasureNumbering :: MeasureNumberingValue -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> MeasureNumbering

-- | text content
[measureNumberingMeasureNumberingValue] :: MeasureNumbering -> MeasureNumberingValue

-- | <i>default-x</i> attribute
[measureNumberingDefaultX] :: MeasureNumbering -> Maybe Tenths

-- | <i>default-y</i> attribute
[measureNumberingDefaultY] :: MeasureNumbering -> Maybe Tenths

-- | <i>relative-x</i> attribute
[measureNumberingRelativeX] :: MeasureNumbering -> Maybe Tenths

-- | <i>relative-y</i> attribute
[measureNumberingRelativeY] :: MeasureNumbering -> Maybe Tenths

-- | <i>font-family</i> attribute
[measureNumberingFontFamily] :: MeasureNumbering -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[measureNumberingFontStyle] :: MeasureNumbering -> Maybe FontStyle

-- | <i>font-size</i> attribute
[measureNumberingFontSize] :: MeasureNumbering -> Maybe FontSize

-- | <i>font-weight</i> attribute
[measureNumberingFontWeight] :: MeasureNumbering -> Maybe FontWeight

-- | <i>color</i> attribute
[measureNumberingColor] :: MeasureNumbering -> Maybe Color

-- | <i>halign</i> attribute
[measureNumberingHalign] :: MeasureNumbering -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[measureNumberingValign] :: MeasureNumbering -> Maybe Valign
parseMeasureNumbering :: XParse MeasureNumbering

-- | Smart constructor for <a>MeasureNumbering</a>
mkMeasureNumbering :: MeasureNumberingValue -> MeasureNumbering

-- | <tt>measure-repeat</tt> <i>(complex)</i>
--   
--   The measure-repeat type is used for both single and multiple measure
--   repeats. The text of the element indicates the number of measures to
--   be repeated in a single pattern. The slashes attribute specifies the
--   number of slashes to use in the repeat sign. It is 1 if not specified.
--   Both the start and the stop of the measure-repeat must be specified.
--   The text of the element is ignored when the type is stop.
--   
--   The measure-repeat element specifies a notation style for repetitions.
--   The actual music being repeated needs to be repeated within the
--   MusicXML file. This element specifies the notation that indicates the
--   repeat.
data MeasureRepeat
MeasureRepeat :: PositiveIntegerOrEmpty -> StartStop -> Maybe PositiveInteger -> MeasureRepeat

-- | text content
[measureRepeatPositiveIntegerOrEmpty] :: MeasureRepeat -> PositiveIntegerOrEmpty

-- | <i>type</i> attribute
[measureRepeatType] :: MeasureRepeat -> StartStop

-- | <i>slashes</i> attribute
[measureRepeatSlashes] :: MeasureRepeat -> Maybe PositiveInteger
parseMeasureRepeat :: XParse MeasureRepeat

-- | Smart constructor for <a>MeasureRepeat</a>
mkMeasureRepeat :: PositiveIntegerOrEmpty -> StartStop -> MeasureRepeat

-- | <tt>measure-style</tt> <i>(complex)</i>
--   
--   A measure-style indicates a special way to print partial to multiple
--   measures within a part. This includes multiple rests over several
--   measures, repeats of beats, single, or multiple measures, and use of
--   slash notation.
--   
--   The multiple-rest and measure-repeat symbols indicate the number of
--   measures covered in the element content. The beat-repeat and slash
--   elements can cover partial measures. All but the multiple-rest element
--   use a type attribute to indicate starting and stopping the use of the
--   style. The optional number attribute specifies the staff number from
--   top to bottom on the system, as with clef.
data MeasureStyle
MeasureStyle :: Maybe StaffNumber -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe ID -> ChxMeasureStyle -> MeasureStyle

-- | <i>number</i> attribute
[measureStyleNumber] :: MeasureStyle -> Maybe StaffNumber

-- | <i>font-family</i> attribute
[measureStyleFontFamily] :: MeasureStyle -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[measureStyleFontStyle] :: MeasureStyle -> Maybe FontStyle

-- | <i>font-size</i> attribute
[measureStyleFontSize] :: MeasureStyle -> Maybe FontSize

-- | <i>font-weight</i> attribute
[measureStyleFontWeight] :: MeasureStyle -> Maybe FontWeight

-- | <i>color</i> attribute
[measureStyleColor] :: MeasureStyle -> Maybe Color

-- | <i>id</i> attribute
[measureStyleId] :: MeasureStyle -> Maybe ID
[measureStyleMeasureStyle] :: MeasureStyle -> ChxMeasureStyle
parseMeasureStyle :: XParse MeasureStyle

-- | Smart constructor for <a>MeasureStyle</a>
mkMeasureStyle :: ChxMeasureStyle -> MeasureStyle

-- | <tt>metronome</tt> <i>(complex)</i>
--   
--   The metronome type represents metronome marks and other metric
--   relationships. The beat-unit group and per-minute element specify
--   regular metronome marks. The metronome-note and metronome-relation
--   elements allow for the specification of metric modulations and other
--   metric relationships, such as swing tempo marks where two eighths are
--   equated to a quarter note / eighth note triplet. Tied notes can be
--   represented in both types of metronome marks by using the
--   beat-unit-tied and metronome-tied elements. The parentheses attribute
--   indicates whether or not to put the metronome mark in parentheses; its
--   value is no if not specified.
data Metronome
Metronome :: Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe LeftCenterRight -> Maybe ID -> ChxMetronome -> Metronome

-- | <i>parentheses</i> attribute
[metronomeParentheses] :: Metronome -> Maybe YesNo

-- | <i>default-x</i> attribute
[metronomeDefaultX] :: Metronome -> Maybe Tenths

-- | <i>default-y</i> attribute
[metronomeDefaultY] :: Metronome -> Maybe Tenths

-- | <i>relative-x</i> attribute
[metronomeRelativeX] :: Metronome -> Maybe Tenths

-- | <i>relative-y</i> attribute
[metronomeRelativeY] :: Metronome -> Maybe Tenths

-- | <i>font-family</i> attribute
[metronomeFontFamily] :: Metronome -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[metronomeFontStyle] :: Metronome -> Maybe FontStyle

-- | <i>font-size</i> attribute
[metronomeFontSize] :: Metronome -> Maybe FontSize

-- | <i>font-weight</i> attribute
[metronomeFontWeight] :: Metronome -> Maybe FontWeight

-- | <i>color</i> attribute
[metronomeColor] :: Metronome -> Maybe Color

-- | <i>halign</i> attribute
[metronomeHalign] :: Metronome -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[metronomeValign] :: Metronome -> Maybe Valign

-- | <i>justify</i> attribute
[metronomeJustify] :: Metronome -> Maybe LeftCenterRight

-- | <i>id</i> attribute
[metronomeId] :: Metronome -> Maybe ID
[metronomeMetronome] :: Metronome -> ChxMetronome
parseMetronome :: XParse Metronome

-- | Smart constructor for <a>Metronome</a>
mkMetronome :: ChxMetronome -> Metronome

-- | <tt>metronome-beam</tt> <i>(complex)</i>
--   
--   The metronome-beam type works like the beam type in defining metric
--   relationships, but does not include all the attributes available in
--   the beam type.
data MetronomeBeam
MetronomeBeam :: BeamValue -> Maybe BeamLevel -> MetronomeBeam

-- | text content
[metronomeBeamBeamValue] :: MetronomeBeam -> BeamValue

-- | <i>number</i> attribute
[metronomeBeamNumber] :: MetronomeBeam -> Maybe BeamLevel
parseMetronomeBeam :: XParse MetronomeBeam

-- | Smart constructor for <a>MetronomeBeam</a>
mkMetronomeBeam :: BeamValue -> MetronomeBeam

-- | <tt>metronome-note</tt> <i>(complex)</i>
--   
--   The metronome-note type defines the appearance of a note within a
--   metric relationship mark.
data MetronomeNote
MetronomeNote :: NoteTypeValue -> [Empty] -> [MetronomeBeam] -> Maybe MetronomeTied -> Maybe MetronomeTuplet -> MetronomeNote

-- | <i>metronome-type</i> child element
[metronomeNoteMetronomeType] :: MetronomeNote -> NoteTypeValue

-- | <i>metronome-dot</i> child element
[metronomeNoteMetronomeDot] :: MetronomeNote -> [Empty]

-- | <i>metronome-beam</i> child element
[metronomeNoteMetronomeBeam] :: MetronomeNote -> [MetronomeBeam]

-- | <i>metronome-tied</i> child element
[metronomeNoteMetronomeTied] :: MetronomeNote -> Maybe MetronomeTied

-- | <i>metronome-tuplet</i> child element
[metronomeNoteMetronomeTuplet] :: MetronomeNote -> Maybe MetronomeTuplet
parseMetronomeNote :: XParse MetronomeNote

-- | Smart constructor for <a>MetronomeNote</a>
mkMetronomeNote :: NoteTypeValue -> MetronomeNote

-- | <tt>metronome-tied</tt> <i>(complex)</i>
--   
--   The metronome-tied indicates the presence of a tie within a metric
--   relationship mark. As with the tied element, both the start and stop
--   of the tie should be specified, in this case within separate
--   metronome-note elements.
data MetronomeTied
MetronomeTied :: StartStop -> MetronomeTied

-- | <i>type</i> attribute
[metronomeTiedType] :: MetronomeTied -> StartStop
parseMetronomeTied :: XParse MetronomeTied

-- | Smart constructor for <a>MetronomeTied</a>
mkMetronomeTied :: StartStop -> MetronomeTied

-- | <tt>metronome-tuplet</tt> <i>(complex)</i>
--   
--   The metronome-tuplet type uses the same element structure as the
--   time-modification element along with some attributes from the tuplet
--   element.
data MetronomeTuplet
MetronomeTuplet :: MetronomeTuplet -> StartStop -> Maybe YesNo -> Maybe ShowTuplet -> MetronomeTuplet
[metronomeTupletTimeModification] :: MetronomeTuplet -> MetronomeTuplet

-- | <i>type</i> attribute
[metronomeTupletType] :: MetronomeTuplet -> StartStop

-- | <i>bracket</i> attribute
[metronomeTupletBracket] :: MetronomeTuplet -> Maybe YesNo

-- | <i>show-number</i> attribute
[metronomeTupletShowNumber] :: MetronomeTuplet -> Maybe ShowTuplet
parseMetronomeTuplet :: XParse MetronomeTuplet

-- | Smart constructor for <a>MetronomeTuplet</a>
mkMetronomeTuplet :: MetronomeTuplet -> StartStop -> MetronomeTuplet

-- | <tt>midi-device</tt> <i>(complex)</i>
--   
--   The midi-device type corresponds to the DeviceName meta event in
--   Standard MIDI Files. The optional port attribute is a number from 1 to
--   16 that can be used with the unofficial MIDI port (or cable) meta
--   event. Unlike the DeviceName meta event, there can be multiple
--   midi-device elements per MusicXML part starting in MusicXML 3.0. The
--   optional id attribute refers to the score-instrument assigned to this
--   device. If missing, the device assignment affects all score-instrument
--   elements in the score-part.
data MidiDevice
MidiDevice :: String -> Maybe Midi16 -> Maybe IDREF -> MidiDevice

-- | text content
[midiDeviceString] :: MidiDevice -> String

-- | <i>port</i> attribute
[midiDevicePort] :: MidiDevice -> Maybe Midi16

-- | <i>id</i> attribute
[midiDeviceId] :: MidiDevice -> Maybe IDREF
parseMidiDevice :: XParse MidiDevice

-- | Smart constructor for <a>MidiDevice</a>
mkMidiDevice :: String -> MidiDevice

-- | <tt>midi-instrument</tt> <i>(complex)</i>
--   
--   The midi-instrument type defines MIDI 1.0 instrument playback. The
--   midi-instrument element can be a part of either the score-instrument
--   element at the start of a part, or the sound element within a part.
--   The id attribute refers to the score-instrument affected by the
--   change.
data MidiInstrument
MidiInstrument :: IDREF -> Maybe Midi16 -> Maybe String -> Maybe Midi16384 -> Maybe Midi128 -> Maybe Midi128 -> Maybe Percent -> Maybe RotationDegrees -> Maybe RotationDegrees -> MidiInstrument

-- | <i>id</i> attribute
[midiInstrumentId] :: MidiInstrument -> IDREF

-- | <i>midi-channel</i> child element
[midiInstrumentMidiChannel] :: MidiInstrument -> Maybe Midi16

-- | <i>midi-name</i> child element
[midiInstrumentMidiName] :: MidiInstrument -> Maybe String

-- | <i>midi-bank</i> child element
[midiInstrumentMidiBank] :: MidiInstrument -> Maybe Midi16384

-- | <i>midi-program</i> child element
[midiInstrumentMidiProgram] :: MidiInstrument -> Maybe Midi128

-- | <i>midi-unpitched</i> child element
[midiInstrumentMidiUnpitched] :: MidiInstrument -> Maybe Midi128

-- | <i>volume</i> child element
[midiInstrumentVolume] :: MidiInstrument -> Maybe Percent

-- | <i>pan</i> child element
[midiInstrumentPan] :: MidiInstrument -> Maybe RotationDegrees

-- | <i>elevation</i> child element
[midiInstrumentElevation] :: MidiInstrument -> Maybe RotationDegrees
parseMidiInstrument :: XParse MidiInstrument

-- | Smart constructor for <a>MidiInstrument</a>
mkMidiInstrument :: IDREF -> MidiInstrument

-- | <tt>miscellaneous</tt> <i>(complex)</i>
--   
--   If a program has other metadata not yet supported in the MusicXML
--   format, it can go in the miscellaneous element. The miscellaneous type
--   puts each separate part of metadata into its own miscellaneous-field
--   type.
data Miscellaneous
Miscellaneous :: [MiscellaneousField] -> Miscellaneous

-- | <i>miscellaneous-field</i> child element
[miscellaneousMiscellaneousField] :: Miscellaneous -> [MiscellaneousField]
parseMiscellaneous :: XParse Miscellaneous

-- | Smart constructor for <a>Miscellaneous</a>
mkMiscellaneous :: Miscellaneous

-- | <tt>miscellaneous-field</tt> <i>(complex)</i>
--   
--   If a program has other metadata not yet supported in the MusicXML
--   format, each type of metadata can go in a miscellaneous-field element.
--   The required name attribute indicates the type of metadata the element
--   content represents.
data MiscellaneousField
MiscellaneousField :: String -> Token -> MiscellaneousField

-- | text content
[miscellaneousFieldString] :: MiscellaneousField -> String

-- | <i>name</i> attribute
[miscellaneousFieldName] :: MiscellaneousField -> Token
parseMiscellaneousField :: XParse MiscellaneousField

-- | Smart constructor for <a>MiscellaneousField</a>
mkMiscellaneousField :: String -> Token -> MiscellaneousField

-- | <tt>mordent</tt> <i>(complex)</i>
--   
--   The mordent type is used for both represents the mordent sign with the
--   vertical line and the inverted-mordent sign without the line. The long
--   attribute is "no" by default. The approach and departure attributes
--   are used for compound ornaments, indicating how the beginning and
--   ending of the ornament look relative to the main part of the mordent.
data Mordent
Mordent :: Mordent -> Maybe YesNo -> Maybe AboveBelow -> Maybe AboveBelow -> Mordent
[mordentEmptyTrillSound] :: Mordent -> Mordent

-- | <i>long</i> attribute
[mordentLong] :: Mordent -> Maybe YesNo

-- | <i>approach</i> attribute
[mordentApproach] :: Mordent -> Maybe AboveBelow

-- | <i>departure</i> attribute
[mordentDeparture] :: Mordent -> Maybe AboveBelow
parseMordent :: XParse Mordent

-- | Smart constructor for <a>Mordent</a>
mkMordent :: Mordent -> Mordent

-- | <tt>multiple-rest</tt> <i>(complex)</i>
--   
--   The text of the multiple-rest type indicates the number of measures in
--   the multiple rest. Multiple rests may use the 1-bar <i> 2-bar </i>
--   4-bar rest symbols, or a single shape. The use-symbols attribute
--   indicates which to use; it is no if not specified.
data MultipleRest
MultipleRest :: PositiveIntegerOrEmpty -> Maybe YesNo -> MultipleRest

-- | text content
[multipleRestPositiveIntegerOrEmpty] :: MultipleRest -> PositiveIntegerOrEmpty

-- | <i>use-symbols</i> attribute
[multipleRestUseSymbols] :: MultipleRest -> Maybe YesNo
parseMultipleRest :: XParse MultipleRest

-- | Smart constructor for <a>MultipleRest</a>
mkMultipleRest :: PositiveIntegerOrEmpty -> MultipleRest

-- | <tt>name-display</tt> <i>(complex)</i>
--   
--   The name-display type is used for exact formatting of multi-font text
--   in part and group names to the left of the system. The print-object
--   attribute can be used to determine what, if anything, is printed at
--   the start of each system. Enclosure for the display-text element is
--   none by default. Language for the display-text element is Italian
--   ("it") by default.
data NameDisplay
NameDisplay :: Maybe YesNo -> [ChxNameDisplay] -> NameDisplay

-- | <i>print-object</i> attribute
[nameDisplayPrintObject] :: NameDisplay -> Maybe YesNo
[nameDisplayNameDisplay] :: NameDisplay -> [ChxNameDisplay]
parseNameDisplay :: XParse NameDisplay

-- | Smart constructor for <a>NameDisplay</a>
mkNameDisplay :: NameDisplay

-- | <tt>non-arpeggiate</tt> <i>(complex)</i>
--   
--   The non-arpeggiate type indicates that this note is at the top or
--   bottom of a bracket indicating to not arpeggiate these notes. Since
--   this does not involve playback, it is only used on the top or bottom
--   notes, not on each note as for the arpeggiate type.
data NonArpeggiate
NonArpeggiate :: TopBottom -> Maybe NumberLevel -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe AboveBelow -> Maybe Color -> Maybe ID -> NonArpeggiate

-- | <i>type</i> attribute
[nonArpeggiateType] :: NonArpeggiate -> TopBottom

-- | <i>number</i> attribute
[nonArpeggiateNumber] :: NonArpeggiate -> Maybe NumberLevel

-- | <i>default-x</i> attribute
[nonArpeggiateDefaultX] :: NonArpeggiate -> Maybe Tenths

-- | <i>default-y</i> attribute
[nonArpeggiateDefaultY] :: NonArpeggiate -> Maybe Tenths

-- | <i>relative-x</i> attribute
[nonArpeggiateRelativeX] :: NonArpeggiate -> Maybe Tenths

-- | <i>relative-y</i> attribute
[nonArpeggiateRelativeY] :: NonArpeggiate -> Maybe Tenths

-- | <i>placement</i> attribute
[nonArpeggiatePlacement] :: NonArpeggiate -> Maybe AboveBelow

-- | <i>color</i> attribute
[nonArpeggiateColor] :: NonArpeggiate -> Maybe Color

-- | <i>id</i> attribute
[nonArpeggiateId] :: NonArpeggiate -> Maybe ID
parseNonArpeggiate :: XParse NonArpeggiate

-- | Smart constructor for <a>NonArpeggiate</a>
mkNonArpeggiate :: TopBottom -> NonArpeggiate

-- | <tt>notations</tt> <i>(complex)</i>
--   
--   Notations refer to musical notations, not XML notations. Multiple
--   notations are allowed in order to represent multiple editorial levels.
--   The print-object attribute, added in Version 3.0, allows notations to
--   represent details of performance technique, such as fingerings,
--   without having them appear in the score.
data Notations
Notations :: Maybe YesNo -> Maybe ID -> Editorial -> [ChxNotations] -> Notations

-- | <i>print-object</i> attribute
[notationsPrintObject] :: Notations -> Maybe YesNo

-- | <i>id</i> attribute
[notationsId] :: Notations -> Maybe ID
[notationsEditorial] :: Notations -> Editorial
[notationsNotations] :: Notations -> [ChxNotations]
parseNotations :: XParse Notations

-- | Smart constructor for <a>Notations</a>
mkNotations :: Editorial -> Notations

-- | <tt>note</tt> <i>(complex)</i>
--   
--   Notes are the most common type of MusicXML data. The MusicXML format
--   keeps the MuseData distinction between elements used for sound
--   information and elements used for notation information (e.g., tie is
--   used for sound, tied for notation). Thus grace notes do not have a
--   duration element. Cue notes have a duration element, as do forward
--   elements, but no tie elements. Having these two types of information
--   available can make interchange considerably easier, as some programs
--   handle one type of information much more readily than the other.
--   
--   <pre>
--   The print-leger attribute is used to indicate whether leger lines are printed. Notes without leger lines are used to indicate indeterminate high and low notes. By default, it is set to yes. If print-object is set to no, print-leger is interpreted to also be set to no if not present. This attribute is ignored for rests.
--   
--   The dynamics and end-dynamics attributes correspond to MIDI 1.0's Note On and Note Off velocities, respectively. They are expressed in terms of percentages of the default forte value (90 for MIDI 1.0).
--   
--   The attack and release attributes are used to alter the starting and stopping time of the note from when it would otherwise occur based on the flow of durations - information that is specific to a performance. They are expressed in terms of divisions, either positive or negative. A note that starts a tie should not have a release attribute, and a note that stops a tie should not have an attack attribute. The attack and release attributes are independent of each other. The attack attribute only changes the starting time of a note, and the release attribute only changes the stopping time of a note.
--   
--   If a note is played only particular times through a repeat, the time-only attribute shows which times to play the note.
--   
--   The pizzicato attribute is used when just this note is sounded pizzicato, vs. the pizzicato element which changes overall playback between pizzicato and arco.
--   </pre>
data Note
Note :: Maybe YesNo -> Maybe NonNegativeDecimal -> Maybe NonNegativeDecimal -> Maybe Divisions -> Maybe Divisions -> Maybe TimeOnly -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe YesNo -> Maybe YesNo -> Maybe YesNo -> Maybe YesNo -> Maybe ID -> ChxNote -> Maybe Instrument -> EditorialVoice -> Maybe NoteType -> [EmptyPlacement] -> Maybe Accidental -> Maybe TimeModification -> Maybe Stem -> Maybe Notehead -> Maybe NoteheadText -> Maybe Staff -> [Beam] -> [Notations] -> [Lyric] -> Maybe Play -> Note

-- | <i>print-leger</i> attribute
[notePrintLeger] :: Note -> Maybe YesNo

-- | <i>dynamics</i> attribute
[noteDynamics] :: Note -> Maybe NonNegativeDecimal

-- | <i>end-dynamics</i> attribute
[noteEndDynamics] :: Note -> Maybe NonNegativeDecimal

-- | <i>attack</i> attribute
[noteAttack] :: Note -> Maybe Divisions

-- | <i>release</i> attribute
[noteRelease] :: Note -> Maybe Divisions

-- | <i>time-only</i> attribute
[noteTimeOnly] :: Note -> Maybe TimeOnly

-- | <i>pizzicato</i> attribute
[notePizzicato] :: Note -> Maybe YesNo

-- | <i>default-x</i> attribute
[noteDefaultX] :: Note -> Maybe Tenths

-- | <i>default-y</i> attribute
[noteDefaultY] :: Note -> Maybe Tenths

-- | <i>relative-x</i> attribute
[noteRelativeX] :: Note -> Maybe Tenths

-- | <i>relative-y</i> attribute
[noteRelativeY] :: Note -> Maybe Tenths

-- | <i>font-family</i> attribute
[noteFontFamily] :: Note -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[noteFontStyle] :: Note -> Maybe FontStyle

-- | <i>font-size</i> attribute
[noteFontSize] :: Note -> Maybe FontSize

-- | <i>font-weight</i> attribute
[noteFontWeight] :: Note -> Maybe FontWeight

-- | <i>color</i> attribute
[noteColor] :: Note -> Maybe Color

-- | <i>print-dot</i> attribute
[notePrintDot] :: Note -> Maybe YesNo

-- | <i>print-lyric</i> attribute
[notePrintLyric] :: Note -> Maybe YesNo

-- | <i>print-object</i> attribute
[notePrintObject] :: Note -> Maybe YesNo

-- | <i>print-spacing</i> attribute
[notePrintSpacing] :: Note -> Maybe YesNo

-- | <i>id</i> attribute
[noteId] :: Note -> Maybe ID
[noteNote] :: Note -> ChxNote

-- | <i>instrument</i> child element
[noteInstrument] :: Note -> Maybe Instrument
[noteEditorialVoice] :: Note -> EditorialVoice

-- | <i>type</i> child element
[noteType] :: Note -> Maybe NoteType

-- | <i>dot</i> child element
[noteDot] :: Note -> [EmptyPlacement]

-- | <i>accidental</i> child element
[noteAccidental] :: Note -> Maybe Accidental

-- | <i>time-modification</i> child element
[noteTimeModification] :: Note -> Maybe TimeModification

-- | <i>stem</i> child element
[noteStem] :: Note -> Maybe Stem

-- | <i>notehead</i> child element
[noteNotehead] :: Note -> Maybe Notehead

-- | <i>notehead-text</i> child element
[noteNoteheadText] :: Note -> Maybe NoteheadText
[noteStaff] :: Note -> Maybe Staff

-- | <i>beam</i> child element
[noteBeam] :: Note -> [Beam]

-- | <i>notations</i> child element
[noteNotations] :: Note -> [Notations]

-- | <i>lyric</i> child element
[noteLyric] :: Note -> [Lyric]

-- | <i>play</i> child element
[notePlay] :: Note -> Maybe Play
parseNote :: XParse Note

-- | Smart constructor for <a>Note</a>
mkNote :: ChxNote -> EditorialVoice -> Note

-- | <tt>note-size</tt> <i>(complex)</i>
--   
--   The note-size type indicates the percentage of the regular note size
--   to use for notes with a cue and large size as defined in the type
--   element. The grace type is used for notes of cue size that that
--   include a grace element. The cue type is used for all other notes with
--   cue size, whether defined explicitly or implicitly via a cue element.
--   The large type is used for notes of large size. The text content
--   represent the numeric percentage. A value of 100 would be identical to
--   the size of a regular note as defined by the music font.
data NoteSize
NoteSize :: NonNegativeDecimal -> NoteSizeType -> NoteSize

-- | text content
[noteSizeNonNegativeDecimal] :: NoteSize -> NonNegativeDecimal

-- | <i>type</i> attribute
[noteSizeType] :: NoteSize -> NoteSizeType
parseNoteSize :: XParse NoteSize

-- | Smart constructor for <a>NoteSize</a>
mkNoteSize :: NonNegativeDecimal -> NoteSizeType -> NoteSize

-- | <tt>note-type</tt> <i>(complex)</i>
--   
--   The note-type type indicates the graphic note type. Values range from
--   1024th to maxima. The size attribute indicates full, cue, grace-cue,
--   or large size. The default is full for regular notes, grace-cue for
--   notes that contain both grace and cue elements, and cue for notes that
--   contain either a cue or a grace element, but not both.
data NoteType
NoteType :: NoteTypeValue -> Maybe SymbolSize -> NoteType

-- | text content
[noteTypeNoteTypeValue] :: NoteType -> NoteTypeValue

-- | <i>size</i> attribute
[noteTypeSize] :: NoteType -> Maybe SymbolSize
parseNoteType :: XParse NoteType

-- | Smart constructor for <a>NoteType</a>
mkNoteType :: NoteTypeValue -> NoteType

-- | <tt>notehead</tt> <i>(complex)</i>
--   
--   The notehead type indicates shapes other than the open and closed
--   ovals associated with note durations.
--   
--   The smufl attribute can be used to specify a particular notehead,
--   allowing application interoperability without requiring every SMuFL
--   glyph to have a MusicXML element equivalent. This attribute can be
--   used either with the "other" value, or to refine a specific notehead
--   value such as "cluster". Noteheads in the SMuFL "Note name noteheads"
--   range (U+E150–U+E1AF) should not use the smufl attribute or the
--   "other" value, but instead use the notehead-text element.
--   
--   For the enclosed shapes, the default is to be hollow for half notes
--   and longer, and filled otherwise. The filled attribute can be set to
--   change this if needed.
--   
--   If the parentheses attribute is set to yes, the notehead is
--   parenthesized. It is no by default.
data Notehead
Notehead :: NoteheadValue -> Maybe YesNo -> Maybe YesNo -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe SmuflGlyphName -> Notehead

-- | text content
[noteheadNoteheadValue] :: Notehead -> NoteheadValue

-- | <i>filled</i> attribute
[noteheadFilled] :: Notehead -> Maybe YesNo

-- | <i>parentheses</i> attribute
[noteheadParentheses] :: Notehead -> Maybe YesNo

-- | <i>font-family</i> attribute
[noteheadFontFamily] :: Notehead -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[noteheadFontStyle] :: Notehead -> Maybe FontStyle

-- | <i>font-size</i> attribute
[noteheadFontSize] :: Notehead -> Maybe FontSize

-- | <i>font-weight</i> attribute
[noteheadFontWeight] :: Notehead -> Maybe FontWeight

-- | <i>color</i> attribute
[noteheadColor] :: Notehead -> Maybe Color

-- | <i>smufl</i> attribute
[noteheadSmufl] :: Notehead -> Maybe SmuflGlyphName
parseNotehead :: XParse Notehead

-- | Smart constructor for <a>Notehead</a>
mkNotehead :: NoteheadValue -> Notehead

-- | <tt>notehead-text</tt> <i>(complex)</i>
--   
--   The notehead-text type represents text that is displayed inside a
--   notehead, as is done in some educational music. It is not needed for
--   the numbers used in tablature or jianpu notation. The presence of a
--   TAB or jianpu clefs is sufficient to indicate that numbers are used.
--   The display-text and accidental-text elements allow display of fully
--   formatted text and accidentals.
data NoteheadText
NoteheadText :: [ChxNoteheadText] -> NoteheadText
[noteheadTextNoteheadText] :: NoteheadText -> [ChxNoteheadText]
parseNoteheadText :: XParse NoteheadText

-- | Smart constructor for <a>NoteheadText</a>
mkNoteheadText :: NoteheadText

-- | <tt>octave-shift</tt> <i>(complex)</i>
--   
--   The octave shift type indicates where notes are shifted up or down
--   from their true pitched values because of printing difficulty. Thus a
--   treble clef line noted with 8va will be indicated with an octave-shift
--   down from the pitch data indicated in the notes. A size of 8 indicates
--   one octave; a size of 15 indicates two octaves.
data OctaveShift
OctaveShift :: UpDownStopContinue -> Maybe NumberLevel -> Maybe PositiveInteger -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe ID -> OctaveShift

-- | <i>type</i> attribute
[octaveShiftType] :: OctaveShift -> UpDownStopContinue

-- | <i>number</i> attribute
[octaveShiftNumber] :: OctaveShift -> Maybe NumberLevel

-- | <i>size</i> attribute
[octaveShiftSize] :: OctaveShift -> Maybe PositiveInteger

-- | <i>dash-length</i> attribute
[octaveShiftDashLength] :: OctaveShift -> Maybe Tenths

-- | <i>space-length</i> attribute
[octaveShiftSpaceLength] :: OctaveShift -> Maybe Tenths

-- | <i>default-x</i> attribute
[octaveShiftDefaultX] :: OctaveShift -> Maybe Tenths

-- | <i>default-y</i> attribute
[octaveShiftDefaultY] :: OctaveShift -> Maybe Tenths

-- | <i>relative-x</i> attribute
[octaveShiftRelativeX] :: OctaveShift -> Maybe Tenths

-- | <i>relative-y</i> attribute
[octaveShiftRelativeY] :: OctaveShift -> Maybe Tenths

-- | <i>font-family</i> attribute
[octaveShiftFontFamily] :: OctaveShift -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[octaveShiftFontStyle] :: OctaveShift -> Maybe FontStyle

-- | <i>font-size</i> attribute
[octaveShiftFontSize] :: OctaveShift -> Maybe FontSize

-- | <i>font-weight</i> attribute
[octaveShiftFontWeight] :: OctaveShift -> Maybe FontWeight

-- | <i>color</i> attribute
[octaveShiftColor] :: OctaveShift -> Maybe Color

-- | <i>id</i> attribute
[octaveShiftId] :: OctaveShift -> Maybe ID
parseOctaveShift :: XParse OctaveShift

-- | Smart constructor for <a>OctaveShift</a>
mkOctaveShift :: UpDownStopContinue -> OctaveShift

-- | <tt>offset</tt> <i>(complex)</i>
--   
--   An offset is represented in terms of divisions, and indicates where
--   the direction will appear relative to the current musical location.
--   This affects the visual appearance of the direction. If the sound
--   attribute is "yes", then the offset affects playback too. If the sound
--   attribute is "no", then any sound associated with the direction takes
--   effect at the current location. The sound attribute is "no" by default
--   for compatibility with earlier versions of the MusicXML format. If an
--   element within a direction includes a default-x attribute, the offset
--   value will be ignored when determining the appearance of that element.
data Offset
Offset :: Divisions -> Maybe YesNo -> Offset

-- | text content
[offsetDivisions] :: Offset -> Divisions

-- | <i>sound</i> attribute
[offsetSound] :: Offset -> Maybe YesNo
parseOffset :: XParse Offset

-- | Smart constructor for <a>Offset</a>
mkOffset :: Divisions -> Offset

-- | <tt>opus</tt> <i>(complex)</i>
--   
--   The opus type represents a link to a MusicXML opus document that
--   composes multiple MusicXML scores into a collection.
data Opus
Opus :: String -> Maybe Type -> Maybe Token -> Maybe Token -> Maybe SmpShow -> Maybe Actuate -> Opus

-- | <i>xlink:href</i> attribute
[opusHref] :: Opus -> String

-- | <i>xlink:type</i> attribute
[opusType] :: Opus -> Maybe Type

-- | <i>xlink:role</i> attribute
[opusRole] :: Opus -> Maybe Token

-- | <i>xlink:title</i> attribute
[opusTitle] :: Opus -> Maybe Token

-- | <i>xlink:show</i> attribute
[opusShow] :: Opus -> Maybe SmpShow

-- | <i>xlink:actuate</i> attribute
[opusActuate] :: Opus -> Maybe Actuate
parseOpus :: XParse Opus

-- | Smart constructor for <a>Opus</a>
mkOpus :: String -> Opus

-- | <tt>ornaments</tt> <i>(complex)</i>
--   
--   Ornaments can be any of several types, followed optionally by
--   accidentals. The accidental-mark element's content is represented the
--   same as an accidental element, but with a different name to reflect
--   the different musical meaning.
data Ornaments
Ornaments :: Maybe ID -> [SeqOrnaments] -> Ornaments

-- | <i>id</i> attribute
[ornamentsId] :: Ornaments -> Maybe ID
[ornamentsOrnaments] :: Ornaments -> [SeqOrnaments]
parseOrnaments :: XParse Ornaments

-- | Smart constructor for <a>Ornaments</a>
mkOrnaments :: Ornaments

-- | <tt>other-appearance</tt> <i>(complex)</i>
--   
--   The other-appearance type is used to define any graphical settings not
--   yet in the current version of the MusicXML format. This allows
--   extended representation, though without application interoperability.
data OtherAppearance
OtherAppearance :: String -> Token -> OtherAppearance

-- | text content
[otherAppearanceString] :: OtherAppearance -> String

-- | <i>type</i> attribute
[otherAppearanceType] :: OtherAppearance -> Token
parseOtherAppearance :: XParse OtherAppearance

-- | Smart constructor for <a>OtherAppearance</a>
mkOtherAppearance :: String -> Token -> OtherAppearance

-- | <tt>other-direction</tt> <i>(complex)</i>
--   
--   The other-direction type is used to define any direction symbols not
--   yet in the MusicXML format. The smufl attribute can be used to specify
--   a particular direction symbol, allowing application interoperability
--   without requiring every SMuFL glyph to have a MusicXML element
--   equivalent. Using the other-direction type without the smufl attribute
--   allows for extended representation, though without application
--   interoperability.
data OtherDirection
OtherDirection :: String -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe SmuflGlyphName -> Maybe ID -> OtherDirection

-- | text content
[otherDirectionString] :: OtherDirection -> String

-- | <i>print-object</i> attribute
[otherDirectionPrintObject] :: OtherDirection -> Maybe YesNo

-- | <i>default-x</i> attribute
[otherDirectionDefaultX] :: OtherDirection -> Maybe Tenths

-- | <i>default-y</i> attribute
[otherDirectionDefaultY] :: OtherDirection -> Maybe Tenths

-- | <i>relative-x</i> attribute
[otherDirectionRelativeX] :: OtherDirection -> Maybe Tenths

-- | <i>relative-y</i> attribute
[otherDirectionRelativeY] :: OtherDirection -> Maybe Tenths

-- | <i>font-family</i> attribute
[otherDirectionFontFamily] :: OtherDirection -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[otherDirectionFontStyle] :: OtherDirection -> Maybe FontStyle

-- | <i>font-size</i> attribute
[otherDirectionFontSize] :: OtherDirection -> Maybe FontSize

-- | <i>font-weight</i> attribute
[otherDirectionFontWeight] :: OtherDirection -> Maybe FontWeight

-- | <i>color</i> attribute
[otherDirectionColor] :: OtherDirection -> Maybe Color

-- | <i>halign</i> attribute
[otherDirectionHalign] :: OtherDirection -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[otherDirectionValign] :: OtherDirection -> Maybe Valign

-- | <i>smufl</i> attribute
[otherDirectionSmufl] :: OtherDirection -> Maybe SmuflGlyphName

-- | <i>id</i> attribute
[otherDirectionId] :: OtherDirection -> Maybe ID
parseOtherDirection :: XParse OtherDirection

-- | Smart constructor for <a>OtherDirection</a>
mkOtherDirection :: String -> OtherDirection

-- | <tt>other-notation</tt> <i>(complex)</i>
--   
--   The other-notation type is used to define any notations not yet in the
--   MusicXML format. It handles notations where more specific extension
--   elements such as other-dynamics and other-technical are not
--   appropriate. The smufl attribute can be used to specify a particular
--   notation, allowing application interoperability without requiring
--   every SMuFL glyph to have a MusicXML element equivalent. Using the
--   other-notation type without the smufl attribute allows for extended
--   representation, though without application interoperability.
data OtherNotation
OtherNotation :: String -> StartStopSingle -> Maybe NumberLevel -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe SmuflGlyphName -> Maybe ID -> OtherNotation

-- | text content
[otherNotationString] :: OtherNotation -> String

-- | <i>type</i> attribute
[otherNotationType] :: OtherNotation -> StartStopSingle

-- | <i>number</i> attribute
[otherNotationNumber] :: OtherNotation -> Maybe NumberLevel

-- | <i>print-object</i> attribute
[otherNotationPrintObject] :: OtherNotation -> Maybe YesNo

-- | <i>default-x</i> attribute
[otherNotationDefaultX] :: OtherNotation -> Maybe Tenths

-- | <i>default-y</i> attribute
[otherNotationDefaultY] :: OtherNotation -> Maybe Tenths

-- | <i>relative-x</i> attribute
[otherNotationRelativeX] :: OtherNotation -> Maybe Tenths

-- | <i>relative-y</i> attribute
[otherNotationRelativeY] :: OtherNotation -> Maybe Tenths

-- | <i>font-family</i> attribute
[otherNotationFontFamily] :: OtherNotation -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[otherNotationFontStyle] :: OtherNotation -> Maybe FontStyle

-- | <i>font-size</i> attribute
[otherNotationFontSize] :: OtherNotation -> Maybe FontSize

-- | <i>font-weight</i> attribute
[otherNotationFontWeight] :: OtherNotation -> Maybe FontWeight

-- | <i>color</i> attribute
[otherNotationColor] :: OtherNotation -> Maybe Color

-- | <i>placement</i> attribute
[otherNotationPlacement] :: OtherNotation -> Maybe AboveBelow

-- | <i>smufl</i> attribute
[otherNotationSmufl] :: OtherNotation -> Maybe SmuflGlyphName

-- | <i>id</i> attribute
[otherNotationId] :: OtherNotation -> Maybe ID
parseOtherNotation :: XParse OtherNotation

-- | Smart constructor for <a>OtherNotation</a>
mkOtherNotation :: String -> StartStopSingle -> OtherNotation

-- | <tt>other-placement-text</tt> <i>(complex)</i>
--   
--   The other-placement-text type represents a text element with
--   print-style, placement, and smufl attribute groups. This type is used
--   by MusicXML notation extension elements to allow specification of
--   specific SMuFL glyphs without needed to add every glyph as a MusicXML
--   element.
data OtherPlacementText
OtherPlacementText :: String -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe SmuflGlyphName -> OtherPlacementText

-- | text content
[otherPlacementTextString] :: OtherPlacementText -> String

-- | <i>default-x</i> attribute
[otherPlacementTextDefaultX] :: OtherPlacementText -> Maybe Tenths

-- | <i>default-y</i> attribute
[otherPlacementTextDefaultY] :: OtherPlacementText -> Maybe Tenths

-- | <i>relative-x</i> attribute
[otherPlacementTextRelativeX] :: OtherPlacementText -> Maybe Tenths

-- | <i>relative-y</i> attribute
[otherPlacementTextRelativeY] :: OtherPlacementText -> Maybe Tenths

-- | <i>font-family</i> attribute
[otherPlacementTextFontFamily] :: OtherPlacementText -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[otherPlacementTextFontStyle] :: OtherPlacementText -> Maybe FontStyle

-- | <i>font-size</i> attribute
[otherPlacementTextFontSize] :: OtherPlacementText -> Maybe FontSize

-- | <i>font-weight</i> attribute
[otherPlacementTextFontWeight] :: OtherPlacementText -> Maybe FontWeight

-- | <i>color</i> attribute
[otherPlacementTextColor] :: OtherPlacementText -> Maybe Color

-- | <i>placement</i> attribute
[otherPlacementTextPlacement] :: OtherPlacementText -> Maybe AboveBelow

-- | <i>smufl</i> attribute
[otherPlacementTextSmufl] :: OtherPlacementText -> Maybe SmuflGlyphName
parseOtherPlacementText :: XParse OtherPlacementText

-- | Smart constructor for <a>OtherPlacementText</a>
mkOtherPlacementText :: String -> OtherPlacementText

-- | <tt>other-play</tt> <i>(complex)</i>
--   
--   The other-play element represents other types of playback. The
--   required type attribute indicates the type of playback to which the
--   element content applies.
data OtherPlay
OtherPlay :: String -> Token -> OtherPlay

-- | text content
[otherPlayString] :: OtherPlay -> String

-- | <i>type</i> attribute
[otherPlayType] :: OtherPlay -> Token
parseOtherPlay :: XParse OtherPlay

-- | Smart constructor for <a>OtherPlay</a>
mkOtherPlay :: String -> Token -> OtherPlay

-- | <tt>other-text</tt> <i>(complex)</i>
--   
--   The other-text type represents a text element with a smufl attribute
--   group. This type is used by MusicXML direction extension elements to
--   allow specification of specific SMuFL glyphs without needed to add
--   every glyph as a MusicXML element.
data OtherText
OtherText :: String -> Maybe SmuflGlyphName -> OtherText

-- | text content
[otherTextString] :: OtherText -> String

-- | <i>smufl</i> attribute
[otherTextSmufl] :: OtherText -> Maybe SmuflGlyphName
parseOtherText :: XParse OtherText

-- | Smart constructor for <a>OtherText</a>
mkOtherText :: String -> OtherText

-- | <tt>page-layout</tt> <i>(complex)</i>
--   
--   Page layout can be defined both in score-wide defaults and in the
--   print element. Page margins are specified either for both even and odd
--   pages, or via separate odd and even page number values. The type is
--   not needed when used as part of a print element. If omitted when used
--   in the defaults element, "both" is the default.
data PageLayout
PageLayout :: Maybe SeqPageLayout -> [PageMargins] -> PageLayout
[pageLayoutPageLayout] :: PageLayout -> Maybe SeqPageLayout

-- | <i>page-margins</i> child element
[pageLayoutPageMargins] :: PageLayout -> [PageMargins]
parsePageLayout :: XParse PageLayout

-- | Smart constructor for <a>PageLayout</a>
mkPageLayout :: PageLayout

-- | <tt>page-margins</tt> <i>(complex)</i>
--   
--   Page margins are specified either for both even and odd pages, or via
--   separate odd and even page number values. The type attribute is not
--   needed when used as part of a print element. If omitted when the
--   page-margins type is used in the defaults element, "both" is the
--   default value.
data PageMargins
PageMargins :: Maybe MarginType -> AllMargins -> PageMargins

-- | <i>type</i> attribute
[pageMarginsType] :: PageMargins -> Maybe MarginType
[pageMarginsAllMargins] :: PageMargins -> AllMargins
parsePageMargins :: XParse PageMargins

-- | Smart constructor for <a>PageMargins</a>
mkPageMargins :: AllMargins -> PageMargins

-- | <tt>part</tt> <i>(complex)</i>
data CmpPart
CmpPart :: IDREF -> [Measure] -> CmpPart

-- | <i>id</i> attribute
[partId] :: CmpPart -> IDREF

-- | <i>measure</i> child element
[partMeasure] :: CmpPart -> [Measure]
parseCmpPart :: XParse CmpPart

-- | Smart constructor for <a>CmpPart</a>
mkCmpPart :: IDREF -> CmpPart

-- | <tt>part</tt> <i>(complex)</i>
data Part
Part :: IDREF -> MusicData -> Part

-- | <i>id</i> attribute
[cmppartId] :: Part -> IDREF
[partMusicData] :: Part -> MusicData
parsePart :: XParse Part

-- | Smart constructor for <a>Part</a>
mkPart :: IDREF -> MusicData -> Part

-- | <tt>part-group</tt> <i>(complex)</i>
--   
--   The part-group element indicates groupings of parts in the score,
--   usually indicated by braces and brackets. Braces that are used for
--   multi-staff parts should be defined in the attributes element for that
--   part. The part-group start element appears before the first score-part
--   in the group. The part-group stop element appears after the last
--   score-part in the group.
--   
--   The number attribute is used to distinguish overlapping and nested
--   part-groups, not the sequence of groups. As with parts, groups can
--   have a name and abbreviation. Values for the child elements are
--   ignored at the stop of a group.
--   
--   A part-group element is not needed for a single multi-staff part. By
--   default, multi-staff parts include a brace symbol and (if appropriate
--   given the bar-style) common barlines. The symbol formatting for a
--   multi-staff part can be more fully specified using the part-symbol
--   element.
data PartGroup
PartGroup :: StartStop -> Maybe Token -> Maybe GroupName -> Maybe NameDisplay -> Maybe GroupName -> Maybe NameDisplay -> Maybe GroupSymbol -> Maybe GroupBarline -> Maybe Empty -> Editorial -> PartGroup

-- | <i>type</i> attribute
[partGroupType] :: PartGroup -> StartStop

-- | <i>number</i> attribute
[partGroupNumber] :: PartGroup -> Maybe Token

-- | <i>group-name</i> child element
[partGroupGroupName] :: PartGroup -> Maybe GroupName

-- | <i>group-name-display</i> child element
[partGroupGroupNameDisplay] :: PartGroup -> Maybe NameDisplay

-- | <i>group-abbreviation</i> child element
[partGroupGroupAbbreviation] :: PartGroup -> Maybe GroupName

-- | <i>group-abbreviation-display</i> child element
[partGroupGroupAbbreviationDisplay] :: PartGroup -> Maybe NameDisplay

-- | <i>group-symbol</i> child element
[partGroupGroupSymbol] :: PartGroup -> Maybe GroupSymbol

-- | <i>group-barline</i> child element
[partGroupGroupBarline] :: PartGroup -> Maybe GroupBarline

-- | <i>group-time</i> child element
[partGroupGroupTime] :: PartGroup -> Maybe Empty
[partGroupEditorial] :: PartGroup -> Editorial
parsePartGroup :: XParse PartGroup

-- | Smart constructor for <a>PartGroup</a>
mkPartGroup :: StartStop -> Editorial -> PartGroup

-- | <tt>part-list</tt> <i>(complex)</i>
--   
--   The part-list identifies the different musical parts in this movement.
--   Each part has an ID that is used later within the musical data. Since
--   parts may be encoded separately and combined later, identification
--   elements are present at both the score and score-part levels. There
--   must be at least one score-part, combined as desired with part-group
--   elements that indicate braces and brackets. Parts are ordered from top
--   to bottom in a score based on the order in which they appear in the
--   part-list.
data PartList
PartList :: [GrpPartGroup] -> ScorePart -> [ChxPartList] -> PartList
[partListPartGroup] :: PartList -> [GrpPartGroup]
[partListScorePart] :: PartList -> ScorePart
[partListPartList] :: PartList -> [ChxPartList]
parsePartList :: XParse PartList

-- | Smart constructor for <a>PartList</a>
mkPartList :: ScorePart -> PartList

-- | <tt>part-name</tt> <i>(complex)</i>
--   
--   The part-name type describes the name or abbreviation of a score-part
--   element. Formatting attributes for the part-name element are
--   deprecated in Version 2.0 in favor of the new part-name-display and
--   part-abbreviation-display elements.
data PartName
PartName :: String -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe YesNo -> Maybe LeftCenterRight -> PartName

-- | text content
[partNameString] :: PartName -> String

-- | <i>default-x</i> attribute
[partNameDefaultX] :: PartName -> Maybe Tenths

-- | <i>default-y</i> attribute
[partNameDefaultY] :: PartName -> Maybe Tenths

-- | <i>relative-x</i> attribute
[partNameRelativeX] :: PartName -> Maybe Tenths

-- | <i>relative-y</i> attribute
[partNameRelativeY] :: PartName -> Maybe Tenths

-- | <i>font-family</i> attribute
[partNameFontFamily] :: PartName -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[partNameFontStyle] :: PartName -> Maybe FontStyle

-- | <i>font-size</i> attribute
[partNameFontSize] :: PartName -> Maybe FontSize

-- | <i>font-weight</i> attribute
[partNameFontWeight] :: PartName -> Maybe FontWeight

-- | <i>color</i> attribute
[partNameColor] :: PartName -> Maybe Color

-- | <i>print-object</i> attribute
[partNamePrintObject] :: PartName -> Maybe YesNo

-- | <i>justify</i> attribute
[partNameJustify] :: PartName -> Maybe LeftCenterRight
parsePartName :: XParse PartName

-- | Smart constructor for <a>PartName</a>
mkPartName :: String -> PartName

-- | <tt>part-symbol</tt> <i>(complex)</i>
--   
--   The part-symbol type indicates how a symbol for a multi-staff part is
--   indicated in the score; brace is the default value. The top-staff and
--   bottom-staff elements are used when the brace does not extend across
--   the entire part. For example, in a 3-staff organ part, the top-staff
--   will typically be 1 for the right hand, while the bottom-staff will
--   typically be 2 for the left hand. Staff 3 for the pedals is usually
--   outside the brace.
data PartSymbol
PartSymbol :: GroupSymbolValue -> Maybe StaffNumber -> Maybe StaffNumber -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Color -> PartSymbol

-- | text content
[partSymbolGroupSymbolValue] :: PartSymbol -> GroupSymbolValue

-- | <i>top-staff</i> attribute
[partSymbolTopStaff] :: PartSymbol -> Maybe StaffNumber

-- | <i>bottom-staff</i> attribute
[partSymbolBottomStaff] :: PartSymbol -> Maybe StaffNumber

-- | <i>default-x</i> attribute
[partSymbolDefaultX] :: PartSymbol -> Maybe Tenths

-- | <i>default-y</i> attribute
[partSymbolDefaultY] :: PartSymbol -> Maybe Tenths

-- | <i>relative-x</i> attribute
[partSymbolRelativeX] :: PartSymbol -> Maybe Tenths

-- | <i>relative-y</i> attribute
[partSymbolRelativeY] :: PartSymbol -> Maybe Tenths

-- | <i>color</i> attribute
[partSymbolColor] :: PartSymbol -> Maybe Color
parsePartSymbol :: XParse PartSymbol

-- | Smart constructor for <a>PartSymbol</a>
mkPartSymbol :: GroupSymbolValue -> PartSymbol

-- | <tt>pedal</tt> <i>(complex)</i>
--   
--   The pedal type represents piano pedal marks. In MusicXML 3.1 this
--   includes sostenuto as well as damper pedal marks. The line attribute
--   is yes if pedal lines are used. The sign attribute is yes if Ped,
--   Sost, and * signs are used. For MusicXML 2.0 compatibility, the sign
--   attribute is yes by default if the line attribute is no, and is no by
--   default if the line attribute is yes. If the sign attribute is set to
--   yes and the type is start or sostenuto, the abbreviated attribute is
--   yes if the short P and S signs are used, and no if the full Ped and
--   Sost signs are used. It is no by default. Otherwise the abbreviated
--   attribute is ignored.
--   
--   The change and continue types are used when the line attribute is yes.
--   The change type indicates a pedal lift and retake indicated with an
--   inverted V marking. The continue type allows more precise formatting
--   across system breaks and for more complex pedaling lines. The
--   alignment attributes are ignored if the line attribute is yes.
data Pedal
Pedal :: PedalType -> Maybe NumberLevel -> Maybe YesNo -> Maybe YesNo -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> Pedal

-- | <i>type</i> attribute
[pedalType] :: Pedal -> PedalType

-- | <i>number</i> attribute
[pedalNumber] :: Pedal -> Maybe NumberLevel

-- | <i>line</i> attribute
[pedalLine] :: Pedal -> Maybe YesNo

-- | <i>sign</i> attribute
[pedalSign] :: Pedal -> Maybe YesNo

-- | <i>abbreviated</i> attribute
[pedalAbbreviated] :: Pedal -> Maybe YesNo

-- | <i>default-x</i> attribute
[pedalDefaultX] :: Pedal -> Maybe Tenths

-- | <i>default-y</i> attribute
[pedalDefaultY] :: Pedal -> Maybe Tenths

-- | <i>relative-x</i> attribute
[pedalRelativeX] :: Pedal -> Maybe Tenths

-- | <i>relative-y</i> attribute
[pedalRelativeY] :: Pedal -> Maybe Tenths

-- | <i>font-family</i> attribute
[pedalFontFamily] :: Pedal -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[pedalFontStyle] :: Pedal -> Maybe FontStyle

-- | <i>font-size</i> attribute
[pedalFontSize] :: Pedal -> Maybe FontSize

-- | <i>font-weight</i> attribute
[pedalFontWeight] :: Pedal -> Maybe FontWeight

-- | <i>color</i> attribute
[pedalColor] :: Pedal -> Maybe Color

-- | <i>halign</i> attribute
[pedalHalign] :: Pedal -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[pedalValign] :: Pedal -> Maybe Valign

-- | <i>id</i> attribute
[pedalId] :: Pedal -> Maybe ID
parsePedal :: XParse Pedal

-- | Smart constructor for <a>Pedal</a>
mkPedal :: PedalType -> Pedal

-- | <tt>pedal-tuning</tt> <i>(complex)</i>
--   
--   The pedal-tuning type specifies the tuning of a single harp pedal.
data PedalTuning
PedalTuning :: Step -> Semitones -> PedalTuning

-- | <i>pedal-step</i> child element
[pedalTuningPedalStep] :: PedalTuning -> Step

-- | <i>pedal-alter</i> child element
[pedalTuningPedalAlter] :: PedalTuning -> Semitones
parsePedalTuning :: XParse PedalTuning

-- | Smart constructor for <a>PedalTuning</a>
mkPedalTuning :: Step -> Semitones -> PedalTuning

-- | <tt>per-minute</tt> <i>(complex)</i>
--   
--   The per-minute type can be a number, or a text description including
--   numbers. If a font is specified, it overrides the font specified for
--   the overall metronome element. This allows separate specification of a
--   music font for the beat-unit and a text font for the numeric value, in
--   cases where a single metronome font is not used.
data PerMinute
PerMinute :: String -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> PerMinute

-- | text content
[perMinuteString] :: PerMinute -> String

-- | <i>font-family</i> attribute
[perMinuteFontFamily] :: PerMinute -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[perMinuteFontStyle] :: PerMinute -> Maybe FontStyle

-- | <i>font-size</i> attribute
[perMinuteFontSize] :: PerMinute -> Maybe FontSize

-- | <i>font-weight</i> attribute
[perMinuteFontWeight] :: PerMinute -> Maybe FontWeight
parsePerMinute :: XParse PerMinute

-- | Smart constructor for <a>PerMinute</a>
mkPerMinute :: String -> PerMinute

-- | <tt>percussion</tt> <i>(complex)</i>
--   
--   The percussion element is used to define percussion pictogram symbols.
--   Definitions for these symbols can be found in Kurt Stone's "Music
--   Notation in the Twentieth Century" on pages 206-212 and 223. Some
--   values are added to these based on how usage has evolved in the 30
--   years since Stone's book was published.
data Percussion
Percussion :: Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe EnclosureShape -> Maybe ID -> ChxPercussion -> Percussion

-- | <i>default-x</i> attribute
[percussionDefaultX] :: Percussion -> Maybe Tenths

-- | <i>default-y</i> attribute
[percussionDefaultY] :: Percussion -> Maybe Tenths

-- | <i>relative-x</i> attribute
[percussionRelativeX] :: Percussion -> Maybe Tenths

-- | <i>relative-y</i> attribute
[percussionRelativeY] :: Percussion -> Maybe Tenths

-- | <i>font-family</i> attribute
[percussionFontFamily] :: Percussion -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[percussionFontStyle] :: Percussion -> Maybe FontStyle

-- | <i>font-size</i> attribute
[percussionFontSize] :: Percussion -> Maybe FontSize

-- | <i>font-weight</i> attribute
[percussionFontWeight] :: Percussion -> Maybe FontWeight

-- | <i>color</i> attribute
[percussionColor] :: Percussion -> Maybe Color

-- | <i>halign</i> attribute
[percussionHalign] :: Percussion -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[percussionValign] :: Percussion -> Maybe Valign

-- | <i>enclosure</i> attribute
[percussionEnclosure] :: Percussion -> Maybe EnclosureShape

-- | <i>id</i> attribute
[percussionId] :: Percussion -> Maybe ID
[percussionPercussion] :: Percussion -> ChxPercussion
parsePercussion :: XParse Percussion

-- | Smart constructor for <a>Percussion</a>
mkPercussion :: ChxPercussion -> Percussion

-- | <tt>pitch</tt> <i>(complex)</i>
--   
--   Pitch is represented as a combination of the step of the diatonic
--   scale, the chromatic alteration, and the octave.
data Pitch
Pitch :: Step -> Maybe Semitones -> Octave -> Pitch

-- | <i>step</i> child element
[pitchStep] :: Pitch -> Step

-- | <i>alter</i> child element
[pitchAlter] :: Pitch -> Maybe Semitones

-- | <i>octave</i> child element
[pitchOctave] :: Pitch -> Octave
parsePitch :: XParse Pitch

-- | Smart constructor for <a>Pitch</a>
mkPitch :: Step -> Octave -> Pitch

-- | <tt>pitched</tt> <i>(complex)</i>
--   
--   The pitched-value type represents pictograms for pitched percussion
--   instruments. The smufl attribute is used to distinguish different
--   SMuFL glyphs for a particular pictogram within the tuned mallet
--   percussion pictograms range.
data Pitched
Pitched :: PitchedValue -> Maybe SmuflPictogramGlyphName -> Pitched

-- | text content
[pitchedPitchedValue] :: Pitched -> PitchedValue

-- | <i>smufl</i> attribute
[pitchedSmufl] :: Pitched -> Maybe SmuflPictogramGlyphName
parsePitched :: XParse Pitched

-- | Smart constructor for <a>Pitched</a>
mkPitched :: PitchedValue -> Pitched

-- | <tt>placement-text</tt> <i>(complex)</i>
--   
--   The placement-text type represents a text element with print-style and
--   placement attribute groups.
data PlacementText
PlacementText :: String -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> PlacementText

-- | text content
[placementTextString] :: PlacementText -> String

-- | <i>default-x</i> attribute
[placementTextDefaultX] :: PlacementText -> Maybe Tenths

-- | <i>default-y</i> attribute
[placementTextDefaultY] :: PlacementText -> Maybe Tenths

-- | <i>relative-x</i> attribute
[placementTextRelativeX] :: PlacementText -> Maybe Tenths

-- | <i>relative-y</i> attribute
[placementTextRelativeY] :: PlacementText -> Maybe Tenths

-- | <i>font-family</i> attribute
[placementTextFontFamily] :: PlacementText -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[placementTextFontStyle] :: PlacementText -> Maybe FontStyle

-- | <i>font-size</i> attribute
[placementTextFontSize] :: PlacementText -> Maybe FontSize

-- | <i>font-weight</i> attribute
[placementTextFontWeight] :: PlacementText -> Maybe FontWeight

-- | <i>color</i> attribute
[placementTextColor] :: PlacementText -> Maybe Color

-- | <i>placement</i> attribute
[placementTextPlacement] :: PlacementText -> Maybe AboveBelow
parsePlacementText :: XParse PlacementText

-- | Smart constructor for <a>PlacementText</a>
mkPlacementText :: String -> PlacementText

-- | <tt>play</tt> <i>(complex)</i>
--   
--   The play type, new in Version 3.0, specifies playback techniques to be
--   used in conjunction with the instrument-sound element. When used as
--   part of a sound element, it applies to all notes going forward in
--   score order. In multi-instrument parts, the affected instrument should
--   be specified using the id attribute. When used as part of a note
--   element, it applies to the current note only.
data Play
Play :: Maybe IDREF -> [ChxPlay] -> Play

-- | <i>id</i> attribute
[playId] :: Play -> Maybe IDREF
[playPlay] :: Play -> [ChxPlay]
parsePlay :: XParse Play

-- | Smart constructor for <a>Play</a>
mkPlay :: Play

-- | <tt>principal-voice</tt> <i>(complex)</i>
--   
--   The principal-voice element represents principal and secondary voices
--   in a score, either for analysis or for square bracket symbols that
--   appear in a score. The symbol attribute indicates the type of symbol
--   used at the start of the principal-voice. The content of the
--   principal-voice element is used for analysis and may be any text
--   value. When used for analysis separate from any printed score
--   markings, the symbol attribute should be set to "none".
data PrincipalVoice
PrincipalVoice :: String -> StartStop -> PrincipalVoiceSymbol -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> PrincipalVoice

-- | text content
[principalVoiceString] :: PrincipalVoice -> String

-- | <i>type</i> attribute
[principalVoiceType] :: PrincipalVoice -> StartStop

-- | <i>symbol</i> attribute
[principalVoiceSymbol] :: PrincipalVoice -> PrincipalVoiceSymbol

-- | <i>default-x</i> attribute
[principalVoiceDefaultX] :: PrincipalVoice -> Maybe Tenths

-- | <i>default-y</i> attribute
[principalVoiceDefaultY] :: PrincipalVoice -> Maybe Tenths

-- | <i>relative-x</i> attribute
[principalVoiceRelativeX] :: PrincipalVoice -> Maybe Tenths

-- | <i>relative-y</i> attribute
[principalVoiceRelativeY] :: PrincipalVoice -> Maybe Tenths

-- | <i>font-family</i> attribute
[principalVoiceFontFamily] :: PrincipalVoice -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[principalVoiceFontStyle] :: PrincipalVoice -> Maybe FontStyle

-- | <i>font-size</i> attribute
[principalVoiceFontSize] :: PrincipalVoice -> Maybe FontSize

-- | <i>font-weight</i> attribute
[principalVoiceFontWeight] :: PrincipalVoice -> Maybe FontWeight

-- | <i>color</i> attribute
[principalVoiceColor] :: PrincipalVoice -> Maybe Color

-- | <i>halign</i> attribute
[principalVoiceHalign] :: PrincipalVoice -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[principalVoiceValign] :: PrincipalVoice -> Maybe Valign

-- | <i>id</i> attribute
[principalVoiceId] :: PrincipalVoice -> Maybe ID
parsePrincipalVoice :: XParse PrincipalVoice

-- | Smart constructor for <a>PrincipalVoice</a>
mkPrincipalVoice :: String -> StartStop -> PrincipalVoiceSymbol -> PrincipalVoice

-- | <tt>print</tt> <i>(complex)</i>
--   
--   The print type contains general printing parameters, including the
--   layout elements defined in the layout.mod file. The part-name-display
--   and part-abbreviation-display elements used in the score.mod file may
--   also be used here to change how a part name or abbreviation is
--   displayed over the course of a piece. They take effect when the
--   current measure or a succeeding measure starts a new system.
--   
--   Layout elements in a print statement only apply to the current page,
--   system, staff, or measure. Music that follows continues to take the
--   default values from the layout included in the defaults element.
data Print
Print :: Maybe Tenths -> Maybe YesNo -> Maybe YesNo -> Maybe PositiveInteger -> Maybe Token -> Maybe ID -> Layout -> Maybe MeasureLayout -> Maybe MeasureNumbering -> Maybe NameDisplay -> Maybe NameDisplay -> Print

-- | <i>staff-spacing</i> attribute
[printStaffSpacing] :: Print -> Maybe Tenths

-- | <i>new-system</i> attribute
[printNewSystem] :: Print -> Maybe YesNo

-- | <i>new-page</i> attribute
[printNewPage] :: Print -> Maybe YesNo

-- | <i>blank-page</i> attribute
[printBlankPage] :: Print -> Maybe PositiveInteger

-- | <i>page-number</i> attribute
[printPageNumber] :: Print -> Maybe Token

-- | <i>id</i> attribute
[printId] :: Print -> Maybe ID
[printLayout] :: Print -> Layout

-- | <i>measure-layout</i> child element
[printMeasureLayout] :: Print -> Maybe MeasureLayout

-- | <i>measure-numbering</i> child element
[printMeasureNumbering] :: Print -> Maybe MeasureNumbering

-- | <i>part-name-display</i> child element
[printPartNameDisplay] :: Print -> Maybe NameDisplay

-- | <i>part-abbreviation-display</i> child element
[printPartAbbreviationDisplay] :: Print -> Maybe NameDisplay
parsePrint :: XParse Print

-- | Smart constructor for <a>Print</a>
mkPrint :: Layout -> Print

-- | <tt>repeat</tt> <i>(complex)</i>
--   
--   The repeat type represents repeat marks. The start of the repeat has a
--   forward direction while the end of the repeat has a backward
--   direction. Backward repeats that are not part of an ending can use the
--   times attribute to indicate the number of times the repeated section
--   is played.
data Repeat
Repeat :: BackwardForward -> Maybe NonNegativeInteger -> Maybe Winged -> Repeat

-- | <i>direction</i> attribute
[repeatDirection] :: Repeat -> BackwardForward

-- | <i>times</i> attribute
[repeatTimes] :: Repeat -> Maybe NonNegativeInteger

-- | <i>winged</i> attribute
[repeatWinged] :: Repeat -> Maybe Winged
parseRepeat :: XParse Repeat

-- | Smart constructor for <a>Repeat</a>
mkRepeat :: BackwardForward -> Repeat

-- | <tt>rest</tt> <i>(complex)</i>
--   
--   The rest element indicates notated rests or silences. Rest elements
--   are usually empty, but placement on the staff can be specified using
--   display-step and display-octave elements. If the measure attribute is
--   set to yes, this indicates this is a complete measure rest.
data Rest
Rest :: Maybe YesNo -> Maybe DisplayStepOctave -> Rest

-- | <i>measure</i> attribute
[restMeasure] :: Rest -> Maybe YesNo
[restDisplayStepOctave] :: Rest -> Maybe DisplayStepOctave
parseRest :: XParse Rest

-- | Smart constructor for <a>Rest</a>
mkRest :: Rest

-- | <tt>root</tt> <i>(complex)</i>
--   
--   The root type indicates a pitch like C, D, E vs. a function indication
--   like I, II, III. It is used with chord symbols in popular music. The
--   root element has a root-step and optional root-alter element similar
--   to the step and alter elements, but renamed to distinguish the
--   different musical meanings.
data Root
Root :: RootStep -> Maybe RootAlter -> Root

-- | <i>root-step</i> child element
[rootRootStep] :: Root -> RootStep

-- | <i>root-alter</i> child element
[rootRootAlter] :: Root -> Maybe RootAlter
parseRoot :: XParse Root

-- | Smart constructor for <a>Root</a>
mkRoot :: RootStep -> Root

-- | <tt>root-alter</tt> <i>(complex)</i>
--   
--   The root-alter type represents the chromatic alteration of the root of
--   the current chord within the harmony element. In some chord styles,
--   the text for the root-step element may include root-alter information.
--   In that case, the print-object attribute of the root-alter element can
--   be set to no. The location attribute indicates whether the alteration
--   should appear to the left or the right of the root-step; it is right
--   by default.
data RootAlter
RootAlter :: Semitones -> Maybe LeftRight -> Maybe YesNo -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> RootAlter

-- | text content
[rootAlterSemitones] :: RootAlter -> Semitones

-- | <i>location</i> attribute
[rootAlterLocation] :: RootAlter -> Maybe LeftRight

-- | <i>print-object</i> attribute
[rootAlterPrintObject] :: RootAlter -> Maybe YesNo

-- | <i>default-x</i> attribute
[rootAlterDefaultX] :: RootAlter -> Maybe Tenths

-- | <i>default-y</i> attribute
[rootAlterDefaultY] :: RootAlter -> Maybe Tenths

-- | <i>relative-x</i> attribute
[rootAlterRelativeX] :: RootAlter -> Maybe Tenths

-- | <i>relative-y</i> attribute
[rootAlterRelativeY] :: RootAlter -> Maybe Tenths

-- | <i>font-family</i> attribute
[rootAlterFontFamily] :: RootAlter -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[rootAlterFontStyle] :: RootAlter -> Maybe FontStyle

-- | <i>font-size</i> attribute
[rootAlterFontSize] :: RootAlter -> Maybe FontSize

-- | <i>font-weight</i> attribute
[rootAlterFontWeight] :: RootAlter -> Maybe FontWeight

-- | <i>color</i> attribute
[rootAlterColor] :: RootAlter -> Maybe Color
parseRootAlter :: XParse RootAlter

-- | Smart constructor for <a>RootAlter</a>
mkRootAlter :: Semitones -> RootAlter

-- | <tt>root-step</tt> <i>(complex)</i>
--   
--   The root-step type represents the pitch step of the root of the
--   current chord within the harmony element. The text attribute indicates
--   how the root should appear in a score if not using the element
--   contents.
data RootStep
RootStep :: Step -> Maybe Token -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> RootStep

-- | text content
[rootStepStep] :: RootStep -> Step

-- | <i>text</i> attribute
[rootStepText] :: RootStep -> Maybe Token

-- | <i>default-x</i> attribute
[rootStepDefaultX] :: RootStep -> Maybe Tenths

-- | <i>default-y</i> attribute
[rootStepDefaultY] :: RootStep -> Maybe Tenths

-- | <i>relative-x</i> attribute
[rootStepRelativeX] :: RootStep -> Maybe Tenths

-- | <i>relative-y</i> attribute
[rootStepRelativeY] :: RootStep -> Maybe Tenths

-- | <i>font-family</i> attribute
[rootStepFontFamily] :: RootStep -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[rootStepFontStyle] :: RootStep -> Maybe FontStyle

-- | <i>font-size</i> attribute
[rootStepFontSize] :: RootStep -> Maybe FontSize

-- | <i>font-weight</i> attribute
[rootStepFontWeight] :: RootStep -> Maybe FontWeight

-- | <i>color</i> attribute
[rootStepColor] :: RootStep -> Maybe Color
parseRootStep :: XParse RootStep

-- | Smart constructor for <a>RootStep</a>
mkRootStep :: Step -> RootStep

-- | <tt>scaling</tt> <i>(complex)</i>
--   
--   Margins, page sizes, and distances are all measured in tenths to keep
--   MusicXML data in a consistent coordinate system as much as possible.
--   The translation to absolute units is done with the scaling type, which
--   specifies how many millimeters are equal to how many tenths. For a
--   staff height of 7 mm, millimeters would be set to 7 while tenths is
--   set to 40. The ability to set a formula rather than a single scaling
--   factor helps avoid roundoff errors.
data Scaling
Scaling :: Millimeters -> Tenths -> Scaling

-- | <i>millimeters</i> child element
[scalingMillimeters] :: Scaling -> Millimeters

-- | <i>tenths</i> child element
[scalingTenths] :: Scaling -> Tenths
parseScaling :: XParse Scaling

-- | Smart constructor for <a>Scaling</a>
mkScaling :: Millimeters -> Tenths -> Scaling

-- | <tt>scordatura</tt> <i>(complex)</i>
--   
--   Scordatura string tunings are represented by a series of accord
--   elements, similar to the staff-tuning elements. Strings are numbered
--   from high to low.
data Scordatura
Scordatura :: Maybe ID -> [Accord] -> Scordatura

-- | <i>id</i> attribute
[scordaturaId] :: Scordatura -> Maybe ID

-- | <i>accord</i> child element
[scordaturaAccord] :: Scordatura -> [Accord]
parseScordatura :: XParse Scordatura

-- | Smart constructor for <a>Scordatura</a>
mkScordatura :: Scordatura

-- | <tt>score-instrument</tt> <i>(complex)</i>
--   
--   The score-instrument type represents a single instrument within a
--   score-part. As with the score-part type, each score-instrument has a
--   required ID attribute, a name, and an optional abbreviation.
--   
--   A score-instrument type is also required if the score specifies MIDI
--   1.0 channels, banks, or programs. An initial midi-instrument
--   assignment can also be made here. MusicXML software should be able to
--   automatically assign reasonable channels and instruments without these
--   elements in simple cases, such as where part names match General MIDI
--   instrument names.
data ScoreInstrument
ScoreInstrument :: ID -> String -> Maybe String -> Maybe String -> Maybe ChxScoreInstrument -> Maybe VirtualInstrument -> ScoreInstrument

-- | <i>id</i> attribute
[scoreInstrumentId] :: ScoreInstrument -> ID

-- | <i>instrument-name</i> child element
[scoreInstrumentInstrumentName] :: ScoreInstrument -> String

-- | <i>instrument-abbreviation</i> child element
[scoreInstrumentInstrumentAbbreviation] :: ScoreInstrument -> Maybe String

-- | <i>instrument-sound</i> child element
[scoreInstrumentInstrumentSound] :: ScoreInstrument -> Maybe String
[scoreInstrumentScoreInstrument] :: ScoreInstrument -> Maybe ChxScoreInstrument

-- | <i>virtual-instrument</i> child element
[scoreInstrumentVirtualInstrument] :: ScoreInstrument -> Maybe VirtualInstrument
parseScoreInstrument :: XParse ScoreInstrument

-- | Smart constructor for <a>ScoreInstrument</a>
mkScoreInstrument :: ID -> String -> ScoreInstrument

-- | <tt>score-part</tt> <i>(complex)</i>
--   
--   Each MusicXML part corresponds to a track in a Standard MIDI Format 1
--   file. The score-instrument elements are used when there are multiple
--   instruments per track. The midi-device element is used to make a MIDI
--   device or port assignment for the given track or specific MIDI
--   instruments. Initial midi-instrument assignments may be made here as
--   well.
data CmpScorePart
CmpScorePart :: ID -> Maybe Identification -> PartName -> Maybe NameDisplay -> Maybe PartName -> Maybe NameDisplay -> [String] -> [ScoreInstrument] -> [SeqScorePart] -> CmpScorePart

-- | <i>id</i> attribute
[scorePartId] :: CmpScorePart -> ID

-- | <i>identification</i> child element
[scorePartIdentification] :: CmpScorePart -> Maybe Identification

-- | <i>part-name</i> child element
[scorePartPartName] :: CmpScorePart -> PartName

-- | <i>part-name-display</i> child element
[scorePartPartNameDisplay] :: CmpScorePart -> Maybe NameDisplay

-- | <i>part-abbreviation</i> child element
[scorePartPartAbbreviation] :: CmpScorePart -> Maybe PartName

-- | <i>part-abbreviation-display</i> child element
[scorePartPartAbbreviationDisplay] :: CmpScorePart -> Maybe NameDisplay

-- | <i>group</i> child element
[scorePartGroup] :: CmpScorePart -> [String]

-- | <i>score-instrument</i> child element
[scorePartScoreInstrument] :: CmpScorePart -> [ScoreInstrument]
[scorePartScorePart] :: CmpScorePart -> [SeqScorePart]
parseCmpScorePart :: XParse CmpScorePart

-- | Smart constructor for <a>CmpScorePart</a>
mkCmpScorePart :: ID -> PartName -> CmpScorePart

-- | <tt>score-partwise</tt> <i>(complex)</i>
data ScorePartwise
ScorePartwise :: Maybe Token -> ScoreHeader -> [CmpPart] -> ScorePartwise

-- | <i>version</i> attribute
[scorePartwiseVersion] :: ScorePartwise -> Maybe Token
[scorePartwiseScoreHeader] :: ScorePartwise -> ScoreHeader

-- | <i>part</i> child element
[scorePartwisePart] :: ScorePartwise -> [CmpPart]
parseScorePartwise :: XParse ScorePartwise

-- | Smart constructor for <a>ScorePartwise</a>
mkScorePartwise :: ScoreHeader -> ScorePartwise

-- | <tt>score-timewise</tt> <i>(complex)</i>
data ScoreTimewise
ScoreTimewise :: Maybe Token -> ScoreHeader -> [CmpMeasure] -> ScoreTimewise

-- | <i>version</i> attribute
[scoreTimewiseVersion] :: ScoreTimewise -> Maybe Token
[scoreTimewiseScoreHeader] :: ScoreTimewise -> ScoreHeader

-- | <i>measure</i> child element
[scoreTimewiseMeasure] :: ScoreTimewise -> [CmpMeasure]
parseScoreTimewise :: XParse ScoreTimewise

-- | Smart constructor for <a>ScoreTimewise</a>
mkScoreTimewise :: ScoreHeader -> ScoreTimewise

-- | <tt>segno</tt> <i>(complex)</i>
--   
--   The segno type is the visual indicator of a segno sign. The exact
--   glyph can be specified with the smufl attribute. A sound element is
--   also needed to guide playback applications reliably.
data Segno
Segno :: Maybe SmuflSegnoGlyphName -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> Segno

-- | <i>smufl</i> attribute
[segnoSmufl] :: Segno -> Maybe SmuflSegnoGlyphName

-- | <i>default-x</i> attribute
[segnoDefaultX] :: Segno -> Maybe Tenths

-- | <i>default-y</i> attribute
[segnoDefaultY] :: Segno -> Maybe Tenths

-- | <i>relative-x</i> attribute
[segnoRelativeX] :: Segno -> Maybe Tenths

-- | <i>relative-y</i> attribute
[segnoRelativeY] :: Segno -> Maybe Tenths

-- | <i>font-family</i> attribute
[segnoFontFamily] :: Segno -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[segnoFontStyle] :: Segno -> Maybe FontStyle

-- | <i>font-size</i> attribute
[segnoFontSize] :: Segno -> Maybe FontSize

-- | <i>font-weight</i> attribute
[segnoFontWeight] :: Segno -> Maybe FontWeight

-- | <i>color</i> attribute
[segnoColor] :: Segno -> Maybe Color

-- | <i>halign</i> attribute
[segnoHalign] :: Segno -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[segnoValign] :: Segno -> Maybe Valign

-- | <i>id</i> attribute
[segnoId] :: Segno -> Maybe ID
parseSegno :: XParse Segno

-- | Smart constructor for <a>Segno</a>
mkSegno :: Segno

-- | <tt>slash</tt> <i>(complex)</i>
--   
--   The slash type is used to indicate that slash notation is to be used.
--   If the slash is on every beat, use-stems is no (the default). To
--   indicate rhythms but not pitches, use-stems is set to yes. The type
--   attribute indicates whether this is the start or stop of a slash
--   notation style. The use-dots attribute works as for the beat-repeat
--   element, and only has effect if use-stems is no.
data CmpSlash
CmpSlash :: StartStop -> Maybe YesNo -> Maybe YesNo -> Maybe Slash -> CmpSlash

-- | <i>type</i> attribute
[slashType] :: CmpSlash -> StartStop

-- | <i>use-dots</i> attribute
[slashUseDots] :: CmpSlash -> Maybe YesNo

-- | <i>use-stems</i> attribute
[slashUseStems] :: CmpSlash -> Maybe YesNo
[slashSlash] :: CmpSlash -> Maybe Slash
parseCmpSlash :: XParse CmpSlash

-- | Smart constructor for <a>CmpSlash</a>
mkCmpSlash :: StartStop -> CmpSlash

-- | <tt>slide</tt> <i>(complex)</i>
--   
--   Glissando and slide types both indicate rapidly moving from one pitch
--   to the other so that individual notes are not discerned. The
--   distinction is similar to that between NIFF's glissando and portamento
--   elements. A slide is continuous between two notes and defaults to a
--   solid line. The optional text for a is printed alongside the line.
data Slide
Slide :: String -> StartStop -> Maybe NumberLevel -> Maybe LineType -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe YesNo -> Maybe TrillBeats -> Maybe Percent -> Maybe Percent -> Maybe ID -> Slide

-- | text content
[slideString] :: Slide -> String

-- | <i>type</i> attribute
[slideType] :: Slide -> StartStop

-- | <i>number</i> attribute
[slideNumber] :: Slide -> Maybe NumberLevel

-- | <i>line-type</i> attribute
[slideLineType] :: Slide -> Maybe LineType

-- | <i>dash-length</i> attribute
[slideDashLength] :: Slide -> Maybe Tenths

-- | <i>space-length</i> attribute
[slideSpaceLength] :: Slide -> Maybe Tenths

-- | <i>default-x</i> attribute
[slideDefaultX] :: Slide -> Maybe Tenths

-- | <i>default-y</i> attribute
[slideDefaultY] :: Slide -> Maybe Tenths

-- | <i>relative-x</i> attribute
[slideRelativeX] :: Slide -> Maybe Tenths

-- | <i>relative-y</i> attribute
[slideRelativeY] :: Slide -> Maybe Tenths

-- | <i>font-family</i> attribute
[slideFontFamily] :: Slide -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[slideFontStyle] :: Slide -> Maybe FontStyle

-- | <i>font-size</i> attribute
[slideFontSize] :: Slide -> Maybe FontSize

-- | <i>font-weight</i> attribute
[slideFontWeight] :: Slide -> Maybe FontWeight

-- | <i>color</i> attribute
[slideColor] :: Slide -> Maybe Color

-- | <i>accelerate</i> attribute
[slideAccelerate] :: Slide -> Maybe YesNo

-- | <i>beats</i> attribute
[slideBeats] :: Slide -> Maybe TrillBeats

-- | <i>first-beat</i> attribute
[slideFirstBeat] :: Slide -> Maybe Percent

-- | <i>last-beat</i> attribute
[slideLastBeat] :: Slide -> Maybe Percent

-- | <i>id</i> attribute
[slideId] :: Slide -> Maybe ID
parseSlide :: XParse Slide

-- | Smart constructor for <a>Slide</a>
mkSlide :: String -> StartStop -> Slide

-- | <tt>slur</tt> <i>(complex)</i>
--   
--   Slur types are empty. Most slurs are represented with two elements:
--   one with a start type, and one with a stop type. Slurs can add more
--   elements using a continue type. This is typically used to specify the
--   formatting of cross-system slurs, or to specify the shape of very
--   complex slurs.
data Slur
Slur :: StartStopContinue -> Maybe NumberLevel -> Maybe LineType -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe AboveBelow -> Maybe OverUnder -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Divisions -> Maybe Divisions -> Maybe Color -> Maybe ID -> Slur

-- | <i>type</i> attribute
[slurType] :: Slur -> StartStopContinue

-- | <i>number</i> attribute
[slurNumber] :: Slur -> Maybe NumberLevel

-- | <i>line-type</i> attribute
[slurLineType] :: Slur -> Maybe LineType

-- | <i>dash-length</i> attribute
[slurDashLength] :: Slur -> Maybe Tenths

-- | <i>space-length</i> attribute
[slurSpaceLength] :: Slur -> Maybe Tenths

-- | <i>default-x</i> attribute
[slurDefaultX] :: Slur -> Maybe Tenths

-- | <i>default-y</i> attribute
[slurDefaultY] :: Slur -> Maybe Tenths

-- | <i>relative-x</i> attribute
[slurRelativeX] :: Slur -> Maybe Tenths

-- | <i>relative-y</i> attribute
[slurRelativeY] :: Slur -> Maybe Tenths

-- | <i>placement</i> attribute
[slurPlacement] :: Slur -> Maybe AboveBelow

-- | <i>orientation</i> attribute
[slurOrientation] :: Slur -> Maybe OverUnder

-- | <i>bezier-x</i> attribute
[slurBezierX] :: Slur -> Maybe Tenths

-- | <i>bezier-y</i> attribute
[slurBezierY] :: Slur -> Maybe Tenths

-- | <i>bezier-x2</i> attribute
[slurBezierX2] :: Slur -> Maybe Tenths

-- | <i>bezier-y2</i> attribute
[slurBezierY2] :: Slur -> Maybe Tenths

-- | <i>bezier-offset</i> attribute
[slurBezierOffset] :: Slur -> Maybe Divisions

-- | <i>bezier-offset2</i> attribute
[slurBezierOffset2] :: Slur -> Maybe Divisions

-- | <i>color</i> attribute
[slurColor] :: Slur -> Maybe Color

-- | <i>id</i> attribute
[slurId] :: Slur -> Maybe ID
parseSlur :: XParse Slur

-- | Smart constructor for <a>Slur</a>
mkSlur :: StartStopContinue -> Slur

-- | <tt>sound</tt> <i>(complex)</i>
--   
--   The sound element contains general playback parameters. They can stand
--   alone within a part/measure, or be a component element within a
--   direction.
--   
--   <pre>
--   Tempo is expressed in quarter notes per minute. If 0, the sound-generating program should prompt the user at the time of compiling a sound (MIDI) file.
--   
--   Dynamics (or MIDI velocity) are expressed as a percentage of the default forte value (90 for MIDI 1.0).
--   
--   Dacapo indicates to go back to the beginning of the movement. When used it always has the value "yes".
--   
--   Segno and dalsegno are used for backwards jumps to a segno sign; coda and tocoda are used for forward jumps to a coda sign. If there are multiple jumps, the value of these parameters can be used to name and distinguish them. If segno or coda is used, the divisions attribute can also be used to indicate the number of divisions per quarter note. Otherwise sound and MIDI generating programs may have to recompute this.
--   
--   By default, a dalsegno or dacapo attribute indicates that the jump should occur the first time through, while a tocoda attribute indicates the jump should occur the second time through. The time that jumps occur can be changed by using the time-only attribute.
--   
--   Forward-repeat is used when a forward repeat sign is implied, and usually follows a bar line. When used it always has the value of "yes".
--   
--   The fine attribute follows the final note or rest in a movement with a da capo or dal segno direction. If numeric, the value represents the actual duration of the final note or rest, which can be ambiguous in written notation and different among parts and voices. The value may also be "yes" to indicate no change to the final duration.
--   
--   If the sound element applies only particular times through a repeat, the time-only attribute indicates which times to apply the sound element.
--   
--   Pizzicato in a sound element effects all following notes. Yes indicates pizzicato, no indicates arco.
--   
--   The pan and elevation attributes are deprecated in Version 2.0. The pan and elevation elements in the midi-instrument element should be used instead. The meaning of the pan and elevation attributes is the same as for the pan and elevation elements. If both are present, the mid-instrument elements take priority.
--   
--   The damper-pedal, soft-pedal, and sostenuto-pedal attributes effect playback of the three common piano pedals and their MIDI controller equivalents. The yes value indicates the pedal is depressed; no indicates the pedal is released. A numeric value from 0 to 100 may also be used for half pedaling. This value is the percentage that the pedal is depressed. A value of 0 is equivalent to no, and a value of 100 is equivalent to yes.
--   
--   MIDI devices, MIDI instruments, and playback techniques are changed using the midi-device, midi-instrument, and play elements. When there are multiple instances of these elements, they should be grouped together by instrument using the id attribute values.
--   
--   The offset element is used to indicate that the sound takes place offset from the current score position. If the sound element is a child of a direction element, the sound offset element overrides the direction offset element if both elements are present. Note that the offset reflects the intended musical position for the change in sound. It should not be used to compensate for latency issues in particular hardware configurations.
--   </pre>
data Sound
Sound :: Maybe NonNegativeDecimal -> Maybe NonNegativeDecimal -> Maybe YesNo -> Maybe Token -> Maybe Token -> Maybe Token -> Maybe Token -> Maybe Divisions -> Maybe YesNo -> Maybe Token -> Maybe TimeOnly -> Maybe YesNo -> Maybe RotationDegrees -> Maybe RotationDegrees -> Maybe YesNoNumber -> Maybe YesNoNumber -> Maybe YesNoNumber -> Maybe ID -> [SeqSound] -> Maybe Offset -> Sound

-- | <i>tempo</i> attribute
[soundTempo] :: Sound -> Maybe NonNegativeDecimal

-- | <i>dynamics</i> attribute
[soundDynamics] :: Sound -> Maybe NonNegativeDecimal

-- | <i>dacapo</i> attribute
[soundDacapo] :: Sound -> Maybe YesNo

-- | <i>segno</i> attribute
[soundSegno] :: Sound -> Maybe Token

-- | <i>dalsegno</i> attribute
[soundDalsegno] :: Sound -> Maybe Token

-- | <i>coda</i> attribute
[soundCoda] :: Sound -> Maybe Token

-- | <i>tocoda</i> attribute
[soundTocoda] :: Sound -> Maybe Token

-- | <i>divisions</i> attribute
[soundDivisions] :: Sound -> Maybe Divisions

-- | <i>forward-repeat</i> attribute
[soundForwardRepeat] :: Sound -> Maybe YesNo

-- | <i>fine</i> attribute
[soundFine] :: Sound -> Maybe Token

-- | <i>time-only</i> attribute
[soundTimeOnly] :: Sound -> Maybe TimeOnly

-- | <i>pizzicato</i> attribute
[soundPizzicato] :: Sound -> Maybe YesNo

-- | <i>pan</i> attribute
[soundPan] :: Sound -> Maybe RotationDegrees

-- | <i>elevation</i> attribute
[soundElevation] :: Sound -> Maybe RotationDegrees

-- | <i>damper-pedal</i> attribute
[soundDamperPedal] :: Sound -> Maybe YesNoNumber

-- | <i>soft-pedal</i> attribute
[soundSoftPedal] :: Sound -> Maybe YesNoNumber

-- | <i>sostenuto-pedal</i> attribute
[soundSostenutoPedal] :: Sound -> Maybe YesNoNumber

-- | <i>id</i> attribute
[soundId] :: Sound -> Maybe ID
[soundSound] :: Sound -> [SeqSound]

-- | <i>offset</i> child element
[soundOffset] :: Sound -> Maybe Offset
parseSound :: XParse Sound

-- | Smart constructor for <a>Sound</a>
mkSound :: Sound

-- | <tt>staff-details</tt> <i>(complex)</i>
--   
--   The staff-details element is used to indicate different types of
--   staves. The optional number attribute specifies the staff number from
--   top to bottom on the system, as with clef. The print-object attribute
--   is used to indicate when a staff is not printed in a part, usually in
--   large scores where empty parts are omitted. It is yes by default. If
--   print-spacing is yes while print-object is no, the score is printed in
--   cutaway format where vertical space is left for the empty part.
data StaffDetails
StaffDetails :: Maybe StaffNumber -> Maybe ShowFrets -> Maybe YesNo -> Maybe YesNo -> Maybe StaffType -> Maybe NonNegativeInteger -> [StaffTuning] -> Maybe NonNegativeInteger -> Maybe NonNegativeDecimal -> StaffDetails

-- | <i>number</i> attribute
[staffDetailsNumber] :: StaffDetails -> Maybe StaffNumber

-- | <i>show-frets</i> attribute
[staffDetailsShowFrets] :: StaffDetails -> Maybe ShowFrets

-- | <i>print-object</i> attribute
[staffDetailsPrintObject] :: StaffDetails -> Maybe YesNo

-- | <i>print-spacing</i> attribute
[staffDetailsPrintSpacing] :: StaffDetails -> Maybe YesNo

-- | <i>staff-type</i> child element
[staffDetailsStaffType] :: StaffDetails -> Maybe StaffType

-- | <i>staff-lines</i> child element
[staffDetailsStaffLines] :: StaffDetails -> Maybe NonNegativeInteger

-- | <i>staff-tuning</i> child element
[staffDetailsStaffTuning] :: StaffDetails -> [StaffTuning]

-- | <i>capo</i> child element
[staffDetailsCapo] :: StaffDetails -> Maybe NonNegativeInteger

-- | <i>staff-size</i> child element
[staffDetailsStaffSize] :: StaffDetails -> Maybe NonNegativeDecimal
parseStaffDetails :: XParse StaffDetails

-- | Smart constructor for <a>StaffDetails</a>
mkStaffDetails :: StaffDetails

-- | <tt>staff-divide</tt> <i>(complex)</i>
--   
--   The staff-divide element represents the staff division arrow symbols
--   found at SMuFL code points U+E00B, U+E00C, and U+E00D.
data StaffDivide
StaffDivide :: StaffDivideSymbol -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> StaffDivide

-- | <i>type</i> attribute
[staffDivideType] :: StaffDivide -> StaffDivideSymbol

-- | <i>default-x</i> attribute
[staffDivideDefaultX] :: StaffDivide -> Maybe Tenths

-- | <i>default-y</i> attribute
[staffDivideDefaultY] :: StaffDivide -> Maybe Tenths

-- | <i>relative-x</i> attribute
[staffDivideRelativeX] :: StaffDivide -> Maybe Tenths

-- | <i>relative-y</i> attribute
[staffDivideRelativeY] :: StaffDivide -> Maybe Tenths

-- | <i>font-family</i> attribute
[staffDivideFontFamily] :: StaffDivide -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[staffDivideFontStyle] :: StaffDivide -> Maybe FontStyle

-- | <i>font-size</i> attribute
[staffDivideFontSize] :: StaffDivide -> Maybe FontSize

-- | <i>font-weight</i> attribute
[staffDivideFontWeight] :: StaffDivide -> Maybe FontWeight

-- | <i>color</i> attribute
[staffDivideColor] :: StaffDivide -> Maybe Color

-- | <i>halign</i> attribute
[staffDivideHalign] :: StaffDivide -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[staffDivideValign] :: StaffDivide -> Maybe Valign

-- | <i>id</i> attribute
[staffDivideId] :: StaffDivide -> Maybe ID
parseStaffDivide :: XParse StaffDivide

-- | Smart constructor for <a>StaffDivide</a>
mkStaffDivide :: StaffDivideSymbol -> StaffDivide

-- | <tt>staff-layout</tt> <i>(complex)</i>
--   
--   Staff layout includes the vertical distance from the bottom line of
--   the previous staff in this system to the top line of the staff
--   specified by the number attribute. The optional number attribute
--   refers to staff numbers within the part, from top to bottom on the
--   system. A value of 1 is assumed if not present. When used in the
--   defaults element, the values apply to all parts. This value is ignored
--   for the first staff in a system.
data StaffLayout
StaffLayout :: Maybe StaffNumber -> Maybe Tenths -> StaffLayout

-- | <i>number</i> attribute
[staffLayoutNumber] :: StaffLayout -> Maybe StaffNumber

-- | <i>staff-distance</i> child element
[staffLayoutStaffDistance] :: StaffLayout -> Maybe Tenths
parseStaffLayout :: XParse StaffLayout

-- | Smart constructor for <a>StaffLayout</a>
mkStaffLayout :: StaffLayout

-- | <tt>staff-tuning</tt> <i>(complex)</i>
--   
--   The staff-tuning type specifies the open, non-capo tuning of the lines
--   on a tablature staff.
data StaffTuning
StaffTuning :: Maybe StaffLine -> Tuning -> StaffTuning

-- | <i>line</i> attribute
[staffTuningLine] :: StaffTuning -> Maybe StaffLine
[staffTuningTuning] :: StaffTuning -> Tuning
parseStaffTuning :: XParse StaffTuning

-- | Smart constructor for <a>StaffTuning</a>
mkStaffTuning :: Tuning -> StaffTuning

-- | <tt>stem</tt> <i>(complex)</i>
--   
--   Stems can be down, up, none, or double. For down and up stems, the
--   position attributes can be used to specify stem length. The relative
--   values specify the end of the stem relative to the program default.
--   Default values specify an absolute end stem position. Negative values
--   of relative-y that would flip a stem instead of shortening it are
--   ignored. A stem element associated with a rest refers to a stemlet.
data Stem
Stem :: StemValue -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Color -> Stem

-- | text content
[stemStemValue] :: Stem -> StemValue

-- | <i>default-x</i> attribute
[stemDefaultX] :: Stem -> Maybe Tenths

-- | <i>default-y</i> attribute
[stemDefaultY] :: Stem -> Maybe Tenths

-- | <i>relative-x</i> attribute
[stemRelativeX] :: Stem -> Maybe Tenths

-- | <i>relative-y</i> attribute
[stemRelativeY] :: Stem -> Maybe Tenths

-- | <i>color</i> attribute
[stemColor] :: Stem -> Maybe Color
parseStem :: XParse Stem

-- | Smart constructor for <a>Stem</a>
mkStem :: StemValue -> Stem

-- | <tt>stick</tt> <i>(complex)</i>
--   
--   The stick type represents pictograms where the material of the stick,
--   mallet, or beater is included.The parentheses and dashed-circle
--   attributes indicate the presence of these marks around the round
--   beater part of a pictogram. Values for these attributes are "no" if
--   not present.
data Stick
Stick :: Maybe TipDirection -> Maybe YesNo -> Maybe YesNo -> StickType -> StickMaterial -> Stick

-- | <i>tip</i> attribute
[stickTip] :: Stick -> Maybe TipDirection

-- | <i>parentheses</i> attribute
[stickParentheses] :: Stick -> Maybe YesNo

-- | <i>dashed-circle</i> attribute
[stickDashedCircle] :: Stick -> Maybe YesNo

-- | <i>stick-type</i> child element
[stickStickType] :: Stick -> StickType

-- | <i>stick-material</i> child element
[stickStickMaterial] :: Stick -> StickMaterial
parseStick :: XParse Stick

-- | Smart constructor for <a>Stick</a>
mkStick :: StickType -> StickMaterial -> Stick

-- | <tt>string</tt> <i>(complex)</i>
--   
--   The string type is used with tablature notation, regular notation
--   (where it is often circled), and chord diagrams. String numbers start
--   with 1 for the highest pitched full-length string.
data CmpString
CmpString :: StringNumber -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> CmpString

-- | text content
[stringStringNumber] :: CmpString -> StringNumber

-- | <i>default-x</i> attribute
[stringDefaultX] :: CmpString -> Maybe Tenths

-- | <i>default-y</i> attribute
[stringDefaultY] :: CmpString -> Maybe Tenths

-- | <i>relative-x</i> attribute
[stringRelativeX] :: CmpString -> Maybe Tenths

-- | <i>relative-y</i> attribute
[stringRelativeY] :: CmpString -> Maybe Tenths

-- | <i>font-family</i> attribute
[stringFontFamily] :: CmpString -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[stringFontStyle] :: CmpString -> Maybe FontStyle

-- | <i>font-size</i> attribute
[stringFontSize] :: CmpString -> Maybe FontSize

-- | <i>font-weight</i> attribute
[stringFontWeight] :: CmpString -> Maybe FontWeight

-- | <i>color</i> attribute
[stringColor] :: CmpString -> Maybe Color

-- | <i>placement</i> attribute
[stringPlacement] :: CmpString -> Maybe AboveBelow
parseCmpString :: XParse CmpString

-- | Smart constructor for <a>CmpString</a>
mkCmpString :: StringNumber -> CmpString

-- | <tt>string-mute</tt> <i>(complex)</i>
--   
--   The string-mute type represents string mute on and mute off symbols.
data StringMute
StringMute :: OnOff -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe ID -> StringMute

-- | <i>type</i> attribute
[stringMuteType] :: StringMute -> OnOff

-- | <i>default-x</i> attribute
[stringMuteDefaultX] :: StringMute -> Maybe Tenths

-- | <i>default-y</i> attribute
[stringMuteDefaultY] :: StringMute -> Maybe Tenths

-- | <i>relative-x</i> attribute
[stringMuteRelativeX] :: StringMute -> Maybe Tenths

-- | <i>relative-y</i> attribute
[stringMuteRelativeY] :: StringMute -> Maybe Tenths

-- | <i>font-family</i> attribute
[stringMuteFontFamily] :: StringMute -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[stringMuteFontStyle] :: StringMute -> Maybe FontStyle

-- | <i>font-size</i> attribute
[stringMuteFontSize] :: StringMute -> Maybe FontSize

-- | <i>font-weight</i> attribute
[stringMuteFontWeight] :: StringMute -> Maybe FontWeight

-- | <i>color</i> attribute
[stringMuteColor] :: StringMute -> Maybe Color

-- | <i>halign</i> attribute
[stringMuteHalign] :: StringMute -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[stringMuteValign] :: StringMute -> Maybe Valign

-- | <i>id</i> attribute
[stringMuteId] :: StringMute -> Maybe ID
parseStringMute :: XParse StringMute

-- | Smart constructor for <a>StringMute</a>
mkStringMute :: OnOff -> StringMute

-- | <tt>strong-accent</tt> <i>(complex)</i>
--   
--   The strong-accent type indicates a vertical accent mark. The type
--   attribute indicates if the point of the accent is down or up.
data StrongAccent
StrongAccent :: StrongAccent -> Maybe UpDown -> StrongAccent
[strongAccentEmptyPlacement] :: StrongAccent -> StrongAccent

-- | <i>type</i> attribute
[strongAccentType] :: StrongAccent -> Maybe UpDown
parseStrongAccent :: XParse StrongAccent

-- | Smart constructor for <a>StrongAccent</a>
mkStrongAccent :: StrongAccent -> StrongAccent

-- | <tt>style-text</tt> <i>(complex)</i>
--   
--   The style-text type represents a text element with a print-style
--   attribute group.
data StyleText
StyleText :: String -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> StyleText

-- | text content
[styleTextString] :: StyleText -> String

-- | <i>default-x</i> attribute
[styleTextDefaultX] :: StyleText -> Maybe Tenths

-- | <i>default-y</i> attribute
[styleTextDefaultY] :: StyleText -> Maybe Tenths

-- | <i>relative-x</i> attribute
[styleTextRelativeX] :: StyleText -> Maybe Tenths

-- | <i>relative-y</i> attribute
[styleTextRelativeY] :: StyleText -> Maybe Tenths

-- | <i>font-family</i> attribute
[styleTextFontFamily] :: StyleText -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[styleTextFontStyle] :: StyleText -> Maybe FontStyle

-- | <i>font-size</i> attribute
[styleTextFontSize] :: StyleText -> Maybe FontSize

-- | <i>font-weight</i> attribute
[styleTextFontWeight] :: StyleText -> Maybe FontWeight

-- | <i>color</i> attribute
[styleTextColor] :: StyleText -> Maybe Color
parseStyleText :: XParse StyleText

-- | Smart constructor for <a>StyleText</a>
mkStyleText :: String -> StyleText

-- | <tt>supports</tt> <i>(complex)</i>
--   
--   The supports type indicates if a MusicXML encoding supports a
--   particular MusicXML element. This is recommended for elements like
--   beam, stem, and accidental, where the absence of an element is
--   ambiguous if you do not know if the encoding supports that element.
--   For Version 2.0, the supports element is expanded to allow programs to
--   indicate support for particular attributes or particular values. This
--   lets applications communicate, for example, that all system and/or
--   page breaks are contained in the MusicXML file.
data Supports
Supports :: YesNo -> NMTOKEN -> Maybe NMTOKEN -> Maybe Token -> Supports

-- | <i>type</i> attribute
[supportsType] :: Supports -> YesNo

-- | <i>element</i> attribute
[supportsElement] :: Supports -> NMTOKEN

-- | <i>attribute</i> attribute
[supportsAttribute] :: Supports -> Maybe NMTOKEN

-- | <i>value</i> attribute
[supportsValue] :: Supports -> Maybe Token
parseSupports :: XParse Supports

-- | Smart constructor for <a>Supports</a>
mkSupports :: YesNo -> NMTOKEN -> Supports

-- | <tt>system-dividers</tt> <i>(complex)</i>
--   
--   The system-dividers element indicates the presence or absence of
--   system dividers (also known as system separation marks) between
--   systems displayed on the same page. Dividers on the left and right
--   side of the page are controlled by the left-divider and right-divider
--   elements respectively. The default vertical position is half the
--   system-distance value from the top of the system that is below the
--   divider. The default horizontal position is the left and right system
--   margin, respectively.
--   
--   When used in the print element, the system-dividers element affects
--   the dividers that would appear between the current system and the
--   previous system.
data SystemDividers
SystemDividers :: EmptyPrintObjectStyleAlign -> EmptyPrintObjectStyleAlign -> SystemDividers

-- | <i>left-divider</i> child element
[systemDividersLeftDivider] :: SystemDividers -> EmptyPrintObjectStyleAlign

-- | <i>right-divider</i> child element
[systemDividersRightDivider] :: SystemDividers -> EmptyPrintObjectStyleAlign
parseSystemDividers :: XParse SystemDividers

-- | Smart constructor for <a>SystemDividers</a>
mkSystemDividers :: EmptyPrintObjectStyleAlign -> EmptyPrintObjectStyleAlign -> SystemDividers

-- | <tt>system-layout</tt> <i>(complex)</i>
--   
--   A system is a group of staves that are read and played simultaneously.
--   System layout includes left and right margins and the vertical
--   distance from the previous system. The system distance is measured
--   from the bottom line of the previous system to the top line of the
--   current system. It is ignored for the first system on a page. The top
--   system distance is measured from the page's top margin to the top line
--   of the first system. It is ignored for all but the first system on a
--   page.
--   
--   Sometimes the sum of measure widths in a system may not equal the
--   system width specified by the layout elements due to roundoff or other
--   errors. The behavior when reading MusicXML files in these cases is
--   application-dependent. For instance, applications may find that the
--   system layout data is more reliable than the sum of the measure
--   widths, and adjust the measure widths accordingly.
data SystemLayout
SystemLayout :: Maybe SystemMargins -> Maybe Tenths -> Maybe Tenths -> Maybe SystemDividers -> SystemLayout

-- | <i>system-margins</i> child element
[systemLayoutSystemMargins] :: SystemLayout -> Maybe SystemMargins

-- | <i>system-distance</i> child element
[systemLayoutSystemDistance] :: SystemLayout -> Maybe Tenths

-- | <i>top-system-distance</i> child element
[systemLayoutTopSystemDistance] :: SystemLayout -> Maybe Tenths

-- | <i>system-dividers</i> child element
[systemLayoutSystemDividers] :: SystemLayout -> Maybe SystemDividers
parseSystemLayout :: XParse SystemLayout

-- | Smart constructor for <a>SystemLayout</a>
mkSystemLayout :: SystemLayout

-- | <tt>system-margins</tt> <i>(complex)</i>
--   
--   System margins are relative to the page margins. Positive values
--   indent and negative values reduce the margin size.
data SystemMargins
SystemMargins :: LeftRightMargins -> SystemMargins
[systemMarginsLeftRightMargins] :: SystemMargins -> LeftRightMargins
parseSystemMargins :: XParse SystemMargins

-- | Smart constructor for <a>SystemMargins</a>
mkSystemMargins :: LeftRightMargins -> SystemMargins

-- | <tt>tap</tt> <i>(complex)</i>
--   
--   The tap type indicates a tap on the fretboard. The text content allows
--   specification of the notation; + and T are common choices. If the
--   element is empty, the hand attribute is used to specify the symbol to
--   use. The hand attribute is ignored if the tap glyph is already
--   specified by the text content. If neither text content nor the hand
--   attribute are present, the display is application-specific.
data Tap
Tap :: String -> Maybe TapHand -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Tap

-- | text content
[tapString] :: Tap -> String

-- | <i>hand</i> attribute
[tapHand] :: Tap -> Maybe TapHand

-- | <i>default-x</i> attribute
[tapDefaultX] :: Tap -> Maybe Tenths

-- | <i>default-y</i> attribute
[tapDefaultY] :: Tap -> Maybe Tenths

-- | <i>relative-x</i> attribute
[tapRelativeX] :: Tap -> Maybe Tenths

-- | <i>relative-y</i> attribute
[tapRelativeY] :: Tap -> Maybe Tenths

-- | <i>font-family</i> attribute
[tapFontFamily] :: Tap -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[tapFontStyle] :: Tap -> Maybe FontStyle

-- | <i>font-size</i> attribute
[tapFontSize] :: Tap -> Maybe FontSize

-- | <i>font-weight</i> attribute
[tapFontWeight] :: Tap -> Maybe FontWeight

-- | <i>color</i> attribute
[tapColor] :: Tap -> Maybe Color

-- | <i>placement</i> attribute
[tapPlacement] :: Tap -> Maybe AboveBelow
parseTap :: XParse Tap

-- | Smart constructor for <a>Tap</a>
mkTap :: String -> Tap

-- | <tt>technical</tt> <i>(complex)</i>
--   
--   Technical indications give performance information for individual
--   instruments.
data Technical
Technical :: Maybe ID -> [ChxTechnical] -> Technical

-- | <i>id</i> attribute
[technicalId] :: Technical -> Maybe ID
[technicalTechnical] :: Technical -> [ChxTechnical]
parseTechnical :: XParse Technical

-- | Smart constructor for <a>Technical</a>
mkTechnical :: Technical

-- | <tt>text-element-data</tt> <i>(complex)</i>
--   
--   The text-element-data type represents a syllable or portion of a
--   syllable for lyric text underlay. A hyphen in the string content
--   should only be used for an actual hyphenated word. Language names for
--   text elements come from ISO 639, with optional country subcodes from
--   ISO 3166.
data TextElementData
TextElementData :: String -> Maybe Lang -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe NumberOfLines -> Maybe RotationDegrees -> Maybe NumberOrNormal -> Maybe TextDirection -> TextElementData

-- | text content
[textElementDataString] :: TextElementData -> String

-- | <i>xml:lang</i> attribute
[textElementDataLang] :: TextElementData -> Maybe Lang

-- | <i>font-family</i> attribute
[textElementDataFontFamily] :: TextElementData -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[textElementDataFontStyle] :: TextElementData -> Maybe FontStyle

-- | <i>font-size</i> attribute
[textElementDataFontSize] :: TextElementData -> Maybe FontSize

-- | <i>font-weight</i> attribute
[textElementDataFontWeight] :: TextElementData -> Maybe FontWeight

-- | <i>color</i> attribute
[textElementDataColor] :: TextElementData -> Maybe Color

-- | <i>underline</i> attribute
[textElementDataUnderline] :: TextElementData -> Maybe NumberOfLines

-- | <i>overline</i> attribute
[textElementDataOverline] :: TextElementData -> Maybe NumberOfLines

-- | <i>line-through</i> attribute
[textElementDataLineThrough] :: TextElementData -> Maybe NumberOfLines

-- | <i>rotation</i> attribute
[textElementDataRotation] :: TextElementData -> Maybe RotationDegrees

-- | <i>letter-spacing</i> attribute
[textElementDataLetterSpacing] :: TextElementData -> Maybe NumberOrNormal

-- | <i>dir</i> attribute
[textElementDataDir] :: TextElementData -> Maybe TextDirection
parseTextElementData :: XParse TextElementData

-- | Smart constructor for <a>TextElementData</a>
mkTextElementData :: String -> TextElementData

-- | <tt>tie</tt> <i>(complex)</i>
--   
--   The tie element indicates that a tie begins or ends with this note. If
--   the tie element applies only particular times through a repeat, the
--   time-only attribute indicates which times to apply it. The tie element
--   indicates sound; the tied element indicates notation.
data Tie
Tie :: StartStop -> Maybe TimeOnly -> Tie

-- | <i>type</i> attribute
[tieType] :: Tie -> StartStop

-- | <i>time-only</i> attribute
[tieTimeOnly] :: Tie -> Maybe TimeOnly
parseTie :: XParse Tie

-- | Smart constructor for <a>Tie</a>
mkTie :: StartStop -> Tie

-- | <tt>tied</tt> <i>(complex)</i>
--   
--   The tied element represents the notated tie. The tie element
--   represents the tie sound.
--   
--   The number attribute is rarely needed to disambiguate ties, since note
--   pitches will usually suffice. The attribute is implied rather than
--   defaulting to 1 as with most elements. It is available for use in more
--   complex tied notation situations.
--   
--   Ties that join two notes of the same pitch together should be
--   represented with a tied element on the first note with type="start"
--   and a tied element on the second note with type="stop". This can also
--   be done if the two notes being tied are enharmonically equivalent, but
--   have different step values. It is not recommended to use tied elements
--   to join two notes with enharmonically inequivalent pitches.
--   
--   Ties that indicate that an instrument should be undamped are specified
--   with a single tied element with type="let-ring".
--   
--   Ties that are visually attached to only one note, other than undamped
--   ties, should be specified with two tied elements on the same note,
--   first type="start" then type="stop". This can be used to represent
--   ties into or out of repeated sections or codas.
data Tied
Tied :: TiedType -> Maybe NumberLevel -> Maybe LineType -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe AboveBelow -> Maybe OverUnder -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Divisions -> Maybe Divisions -> Maybe Color -> Maybe ID -> Tied

-- | <i>type</i> attribute
[tiedType] :: Tied -> TiedType

-- | <i>number</i> attribute
[tiedNumber] :: Tied -> Maybe NumberLevel

-- | <i>line-type</i> attribute
[tiedLineType] :: Tied -> Maybe LineType

-- | <i>dash-length</i> attribute
[tiedDashLength] :: Tied -> Maybe Tenths

-- | <i>space-length</i> attribute
[tiedSpaceLength] :: Tied -> Maybe Tenths

-- | <i>default-x</i> attribute
[tiedDefaultX] :: Tied -> Maybe Tenths

-- | <i>default-y</i> attribute
[tiedDefaultY] :: Tied -> Maybe Tenths

-- | <i>relative-x</i> attribute
[tiedRelativeX] :: Tied -> Maybe Tenths

-- | <i>relative-y</i> attribute
[tiedRelativeY] :: Tied -> Maybe Tenths

-- | <i>placement</i> attribute
[tiedPlacement] :: Tied -> Maybe AboveBelow

-- | <i>orientation</i> attribute
[tiedOrientation] :: Tied -> Maybe OverUnder

-- | <i>bezier-x</i> attribute
[tiedBezierX] :: Tied -> Maybe Tenths

-- | <i>bezier-y</i> attribute
[tiedBezierY] :: Tied -> Maybe Tenths

-- | <i>bezier-x2</i> attribute
[tiedBezierX2] :: Tied -> Maybe Tenths

-- | <i>bezier-y2</i> attribute
[tiedBezierY2] :: Tied -> Maybe Tenths

-- | <i>bezier-offset</i> attribute
[tiedBezierOffset] :: Tied -> Maybe Divisions

-- | <i>bezier-offset2</i> attribute
[tiedBezierOffset2] :: Tied -> Maybe Divisions

-- | <i>color</i> attribute
[tiedColor] :: Tied -> Maybe Color

-- | <i>id</i> attribute
[tiedId] :: Tied -> Maybe ID
parseTied :: XParse Tied

-- | Smart constructor for <a>Tied</a>
mkTied :: TiedType -> Tied

-- | <tt>time</tt> <i>(complex)</i>
--   
--   Time signatures are represented by the beats element for the numerator
--   and the beat-type element for the denominator. The symbol attribute is
--   used indicate common and cut time symbols as well as a single number
--   display. Multiple pairs of beat and beat-type elements are used for
--   composite time signatures with multiple denominators, such as 2<i>4 +
--   3</i>8. A composite such as 3+2<i>8 requires only one
--   beat</i>beat-type pair.
--   
--   The print-object attribute allows a time signature to be specified but
--   not printed, as is the case for excerpts from the middle of a score.
--   The value is "yes" if not present. The optional number attribute
--   refers to staff numbers within the part. If absent, the time signature
--   applies to all staves in the part.
data Time
Time :: Maybe StaffNumber -> Maybe TimeSymbol -> Maybe TimeSeparator -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe LeftCenterRight -> Maybe Valign -> Maybe YesNo -> Maybe ID -> ChxTime -> Time

-- | <i>number</i> attribute
[timeNumber] :: Time -> Maybe StaffNumber

-- | <i>symbol</i> attribute
[timeSymbol] :: Time -> Maybe TimeSymbol

-- | <i>separator</i> attribute
[timeSeparator] :: Time -> Maybe TimeSeparator

-- | <i>default-x</i> attribute
[timeDefaultX] :: Time -> Maybe Tenths

-- | <i>default-y</i> attribute
[timeDefaultY] :: Time -> Maybe Tenths

-- | <i>relative-x</i> attribute
[timeRelativeX] :: Time -> Maybe Tenths

-- | <i>relative-y</i> attribute
[timeRelativeY] :: Time -> Maybe Tenths

-- | <i>font-family</i> attribute
[timeFontFamily] :: Time -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[timeFontStyle] :: Time -> Maybe FontStyle

-- | <i>font-size</i> attribute
[timeFontSize] :: Time -> Maybe FontSize

-- | <i>font-weight</i> attribute
[timeFontWeight] :: Time -> Maybe FontWeight

-- | <i>color</i> attribute
[timeColor] :: Time -> Maybe Color

-- | <i>halign</i> attribute
[timeHalign] :: Time -> Maybe LeftCenterRight

-- | <i>valign</i> attribute
[timeValign] :: Time -> Maybe Valign

-- | <i>print-object</i> attribute
[timePrintObject] :: Time -> Maybe YesNo

-- | <i>id</i> attribute
[timeId] :: Time -> Maybe ID
[timeTime] :: Time -> ChxTime
parseTime :: XParse Time

-- | Smart constructor for <a>Time</a>
mkTime :: ChxTime -> Time

-- | <tt>time-modification</tt> <i>(complex)</i>
--   
--   Time modification indicates tuplets, double-note tremolos, and other
--   durational changes. A time-modification element shows how the
--   cumulative, sounding effect of tuplets and double-note tremolos
--   compare to the written note type represented by the type and dot
--   elements. Nested tuplets and other notations that use more detailed
--   information need both the time-modification and tuplet elements to be
--   represented accurately.
data TimeModification
TimeModification :: NonNegativeInteger -> NonNegativeInteger -> Maybe SeqTimeModification -> TimeModification

-- | <i>actual-notes</i> child element
[timeModificationActualNotes] :: TimeModification -> NonNegativeInteger

-- | <i>normal-notes</i> child element
[timeModificationNormalNotes] :: TimeModification -> NonNegativeInteger
[timeModificationTimeModification] :: TimeModification -> Maybe SeqTimeModification
parseTimeModification :: XParse TimeModification

-- | Smart constructor for <a>TimeModification</a>
mkTimeModification :: NonNegativeInteger -> NonNegativeInteger -> TimeModification

-- | <tt>transpose</tt> <i>(complex)</i>
--   
--   The transpose type represents what must be added to a written pitch to
--   get a correct sounding pitch. The optional number attribute refers to
--   staff numbers, from top to bottom on the system. If absent, the
--   transposition applies to all staves in the part. Per-staff
--   transposition is most often used in parts that represent multiple
--   instruments.
data Transpose
Transpose :: Maybe StaffNumber -> Maybe ID -> Maybe Int -> Semitones -> Maybe Int -> Maybe Empty -> Transpose

-- | <i>number</i> attribute
[transposeNumber] :: Transpose -> Maybe StaffNumber

-- | <i>id</i> attribute
[transposeId] :: Transpose -> Maybe ID

-- | <i>diatonic</i> child element
[transposeDiatonic] :: Transpose -> Maybe Int

-- | <i>chromatic</i> child element
[transposeChromatic] :: Transpose -> Semitones

-- | <i>octave-change</i> child element
[transposeOctaveChange] :: Transpose -> Maybe Int

-- | <i>double</i> child element
[transposeDouble] :: Transpose -> Maybe Empty
parseTranspose :: XParse Transpose

-- | Smart constructor for <a>Transpose</a>
mkTranspose :: Semitones -> Transpose

-- | <tt>tremolo</tt> <i>(complex)</i>
--   
--   The tremolo ornament can be used to indicate single-note, double-note,
--   or unmeasured tremolos. Single-note tremolos use the single type,
--   double-note tremolos use the start and stop types, and unmeasured
--   tremolos use the unmeasured type. The default is "single" for
--   compatibility with Version 1.1. The text of the element indicates the
--   number of tremolo marks and is an integer from 0 to 8. Note that the
--   number of attached beams is not included in this value, but is
--   represented separately using the beam element. The value should be 0
--   for unmeasured tremolos.
--   
--   When using double-note tremolos, the duration of each note in the
--   tremolo should correspond to half of the notated type value. A
--   time-modification element should also be added with an actual-notes
--   value of 2 and a normal-notes value of 1. If used within a tuplet,
--   this 2/1 ratio should be multiplied by the existing tuplet ratio.
--   
--   The smufl attribute specifies the glyph to use from the SMuFL tremolos
--   range for an unmeasured tremolo. It is ignored for other tremolo
--   types. The SMuFL buzzRoll glyph is used by default if the attribute is
--   missing.
--   
--   Using repeater beams for indicating tremolos is deprecated as of
--   MusicXML 3.0.
data Tremolo
Tremolo :: TremoloMarks -> Maybe TremoloType -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> Maybe AboveBelow -> Maybe SmuflGlyphName -> Tremolo

-- | text content
[tremoloTremoloMarks] :: Tremolo -> TremoloMarks

-- | <i>type</i> attribute
[tremoloType] :: Tremolo -> Maybe TremoloType

-- | <i>default-x</i> attribute
[tremoloDefaultX] :: Tremolo -> Maybe Tenths

-- | <i>default-y</i> attribute
[tremoloDefaultY] :: Tremolo -> Maybe Tenths

-- | <i>relative-x</i> attribute
[tremoloRelativeX] :: Tremolo -> Maybe Tenths

-- | <i>relative-y</i> attribute
[tremoloRelativeY] :: Tremolo -> Maybe Tenths

-- | <i>font-family</i> attribute
[tremoloFontFamily] :: Tremolo -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[tremoloFontStyle] :: Tremolo -> Maybe FontStyle

-- | <i>font-size</i> attribute
[tremoloFontSize] :: Tremolo -> Maybe FontSize

-- | <i>font-weight</i> attribute
[tremoloFontWeight] :: Tremolo -> Maybe FontWeight

-- | <i>color</i> attribute
[tremoloColor] :: Tremolo -> Maybe Color

-- | <i>placement</i> attribute
[tremoloPlacement] :: Tremolo -> Maybe AboveBelow

-- | <i>smufl</i> attribute
[tremoloSmufl] :: Tremolo -> Maybe SmuflGlyphName
parseTremolo :: XParse Tremolo

-- | Smart constructor for <a>Tremolo</a>
mkTremolo :: TremoloMarks -> Tremolo

-- | <tt>tuplet</tt> <i>(complex)</i>
--   
--   A tuplet element is present when a tuplet is to be displayed
--   graphically, in addition to the sound data provided by the
--   time-modification elements. The number attribute is used to
--   distinguish nested tuplets. The bracket attribute is used to indicate
--   the presence of a bracket. If unspecified, the results are
--   implementation-dependent. The line-shape attribute is used to specify
--   whether the bracket is straight or in the older curved or slurred
--   style. It is straight by default.
--   
--   Whereas a time-modification element shows how the cumulative, sounding
--   effect of tuplets and double-note tremolos compare to the written note
--   type, the tuplet element describes how this is displayed. The tuplet
--   element also provides more detailed representation information than
--   the time-modification element, and is needed to represent nested
--   tuplets and other complex tuplets accurately.
--   
--   The show-number attribute is used to display either the number of
--   actual notes, the number of both actual and normal notes, or neither.
--   It is actual by default. The show-type attribute is used to display
--   either the actual type, both the actual and normal types, or neither.
--   It is none by default.
data Tuplet
Tuplet :: StartStop -> Maybe NumberLevel -> Maybe YesNo -> Maybe ShowTuplet -> Maybe ShowTuplet -> Maybe LineShape -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe AboveBelow -> Maybe ID -> Maybe TupletPortion -> Maybe TupletPortion -> Tuplet

-- | <i>type</i> attribute
[tupletType] :: Tuplet -> StartStop

-- | <i>number</i> attribute
[tupletNumber] :: Tuplet -> Maybe NumberLevel

-- | <i>bracket</i> attribute
[tupletBracket] :: Tuplet -> Maybe YesNo

-- | <i>show-number</i> attribute
[tupletShowNumber] :: Tuplet -> Maybe ShowTuplet

-- | <i>show-type</i> attribute
[tupletShowType] :: Tuplet -> Maybe ShowTuplet

-- | <i>line-shape</i> attribute
[tupletLineShape] :: Tuplet -> Maybe LineShape

-- | <i>default-x</i> attribute
[tupletDefaultX] :: Tuplet -> Maybe Tenths

-- | <i>default-y</i> attribute
[tupletDefaultY] :: Tuplet -> Maybe Tenths

-- | <i>relative-x</i> attribute
[tupletRelativeX] :: Tuplet -> Maybe Tenths

-- | <i>relative-y</i> attribute
[tupletRelativeY] :: Tuplet -> Maybe Tenths

-- | <i>placement</i> attribute
[tupletPlacement] :: Tuplet -> Maybe AboveBelow

-- | <i>id</i> attribute
[tupletId] :: Tuplet -> Maybe ID

-- | <i>tuplet-actual</i> child element
[tupletTupletActual] :: Tuplet -> Maybe TupletPortion

-- | <i>tuplet-normal</i> child element
[tupletTupletNormal] :: Tuplet -> Maybe TupletPortion
parseTuplet :: XParse Tuplet

-- | Smart constructor for <a>Tuplet</a>
mkTuplet :: StartStop -> Tuplet

-- | <tt>tuplet-dot</tt> <i>(complex)</i>
--   
--   The tuplet-dot type is used to specify dotted normal tuplet types.
data TupletDot
TupletDot :: Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> TupletDot

-- | <i>font-family</i> attribute
[tupletDotFontFamily] :: TupletDot -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[tupletDotFontStyle] :: TupletDot -> Maybe FontStyle

-- | <i>font-size</i> attribute
[tupletDotFontSize] :: TupletDot -> Maybe FontSize

-- | <i>font-weight</i> attribute
[tupletDotFontWeight] :: TupletDot -> Maybe FontWeight

-- | <i>color</i> attribute
[tupletDotColor] :: TupletDot -> Maybe Color
parseTupletDot :: XParse TupletDot

-- | Smart constructor for <a>TupletDot</a>
mkTupletDot :: TupletDot

-- | <tt>tuplet-number</tt> <i>(complex)</i>
--   
--   The tuplet-number type indicates the number of notes for this portion
--   of the tuplet.
data TupletNumber
TupletNumber :: NonNegativeInteger -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> TupletNumber

-- | text content
[tupletNumberNonNegativeInteger] :: TupletNumber -> NonNegativeInteger

-- | <i>font-family</i> attribute
[tupletNumberFontFamily] :: TupletNumber -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[tupletNumberFontStyle] :: TupletNumber -> Maybe FontStyle

-- | <i>font-size</i> attribute
[tupletNumberFontSize] :: TupletNumber -> Maybe FontSize

-- | <i>font-weight</i> attribute
[tupletNumberFontWeight] :: TupletNumber -> Maybe FontWeight

-- | <i>color</i> attribute
[tupletNumberColor] :: TupletNumber -> Maybe Color
parseTupletNumber :: XParse TupletNumber

-- | Smart constructor for <a>TupletNumber</a>
mkTupletNumber :: NonNegativeInteger -> TupletNumber

-- | <tt>tuplet-portion</tt> <i>(complex)</i>
--   
--   The tuplet-portion type provides optional full control over tuplet
--   specifications. It allows the number and note type (including dots) to
--   be set for the actual and normal portions of a single tuplet. If any
--   of these elements are absent, their values are based on the
--   time-modification element.
data TupletPortion
TupletPortion :: Maybe TupletNumber -> Maybe TupletType -> [TupletDot] -> TupletPortion

-- | <i>tuplet-number</i> child element
[tupletPortionTupletNumber] :: TupletPortion -> Maybe TupletNumber

-- | <i>tuplet-type</i> child element
[tupletPortionTupletType] :: TupletPortion -> Maybe TupletType

-- | <i>tuplet-dot</i> child element
[tupletPortionTupletDot] :: TupletPortion -> [TupletDot]
parseTupletPortion :: XParse TupletPortion

-- | Smart constructor for <a>TupletPortion</a>
mkTupletPortion :: TupletPortion

-- | <tt>tuplet-type</tt> <i>(complex)</i>
--   
--   The tuplet-type type indicates the graphical note type of the notes
--   for this portion of the tuplet.
data TupletType
TupletType :: NoteTypeValue -> Maybe CommaSeparatedText -> Maybe FontStyle -> Maybe FontSize -> Maybe FontWeight -> Maybe Color -> TupletType

-- | text content
[tupletTypeNoteTypeValue] :: TupletType -> NoteTypeValue

-- | <i>font-family</i> attribute
[tupletTypeFontFamily] :: TupletType -> Maybe CommaSeparatedText

-- | <i>font-style</i> attribute
[tupletTypeFontStyle] :: TupletType -> Maybe FontStyle

-- | <i>font-size</i> attribute
[tupletTypeFontSize] :: TupletType -> Maybe FontSize

-- | <i>font-weight</i> attribute
[tupletTypeFontWeight] :: TupletType -> Maybe FontWeight

-- | <i>color</i> attribute
[tupletTypeColor] :: TupletType -> Maybe Color
parseTupletType :: XParse TupletType

-- | Smart constructor for <a>TupletType</a>
mkTupletType :: NoteTypeValue -> TupletType

-- | <tt>typed-text</tt> <i>(complex)</i>
--   
--   The typed-text type represents a text element with a type attributes.
data TypedText
TypedText :: String -> Maybe Token -> TypedText

-- | text content
[typedTextString] :: TypedText -> String

-- | <i>type</i> attribute
[typedTextType] :: TypedText -> Maybe Token
parseTypedText :: XParse TypedText

-- | Smart constructor for <a>TypedText</a>
mkTypedText :: String -> TypedText

-- | <tt>unpitched</tt> <i>(complex)</i>
--   
--   The unpitched type represents musical elements that are notated on the
--   staff but lack definite pitch, such as unpitched percussion and
--   speaking voice.
data Unpitched
Unpitched :: Maybe DisplayStepOctave -> Unpitched
[unpitchedDisplayStepOctave] :: Unpitched -> Maybe DisplayStepOctave
parseUnpitched :: XParse Unpitched

-- | Smart constructor for <a>Unpitched</a>
mkUnpitched :: Unpitched

-- | <tt>virtual-instrument</tt> <i>(complex)</i>
--   
--   The virtual-instrument element defines a specific virtual instrument
--   used for an instrument sound.
data VirtualInstrument
VirtualInstrument :: Maybe String -> Maybe String -> VirtualInstrument

-- | <i>virtual-library</i> child element
[virtualInstrumentVirtualLibrary] :: VirtualInstrument -> Maybe String

-- | <i>virtual-name</i> child element
[virtualInstrumentVirtualName] :: VirtualInstrument -> Maybe String
parseVirtualInstrument :: XParse VirtualInstrument

-- | Smart constructor for <a>VirtualInstrument</a>
mkVirtualInstrument :: VirtualInstrument

-- | <tt>wavy-line</tt> <i>(complex)</i>
--   
--   Wavy lines are one way to indicate trills. When used with a barline
--   element, they should always have type="continue" set.
data WavyLine
WavyLine :: StartStopContinue -> Maybe NumberLevel -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe AboveBelow -> Maybe Color -> Maybe StartNote -> Maybe TrillStep -> Maybe TwoNoteTurn -> Maybe YesNo -> Maybe TrillBeats -> Maybe Percent -> Maybe Percent -> WavyLine

-- | <i>type</i> attribute
[wavyLineType] :: WavyLine -> StartStopContinue

-- | <i>number</i> attribute
[wavyLineNumber] :: WavyLine -> Maybe NumberLevel

-- | <i>default-x</i> attribute
[wavyLineDefaultX] :: WavyLine -> Maybe Tenths

-- | <i>default-y</i> attribute
[wavyLineDefaultY] :: WavyLine -> Maybe Tenths

-- | <i>relative-x</i> attribute
[wavyLineRelativeX] :: WavyLine -> Maybe Tenths

-- | <i>relative-y</i> attribute
[wavyLineRelativeY] :: WavyLine -> Maybe Tenths

-- | <i>placement</i> attribute
[wavyLinePlacement] :: WavyLine -> Maybe AboveBelow

-- | <i>color</i> attribute
[wavyLineColor] :: WavyLine -> Maybe Color

-- | <i>start-note</i> attribute
[wavyLineStartNote] :: WavyLine -> Maybe StartNote

-- | <i>trill-step</i> attribute
[wavyLineTrillStep] :: WavyLine -> Maybe TrillStep

-- | <i>two-note-turn</i> attribute
[wavyLineTwoNoteTurn] :: WavyLine -> Maybe TwoNoteTurn

-- | <i>accelerate</i> attribute
[wavyLineAccelerate] :: WavyLine -> Maybe YesNo

-- | <i>beats</i> attribute
[wavyLineBeats] :: WavyLine -> Maybe TrillBeats

-- | <i>second-beat</i> attribute
[wavyLineSecondBeat] :: WavyLine -> Maybe Percent

-- | <i>last-beat</i> attribute
[wavyLineLastBeat] :: WavyLine -> Maybe Percent
parseWavyLine :: XParse WavyLine

-- | Smart constructor for <a>WavyLine</a>
mkWavyLine :: StartStopContinue -> WavyLine

-- | <tt>wedge</tt> <i>(complex)</i>
--   
--   The wedge type represents crescendo and diminuendo wedge symbols. The
--   type attribute is crescendo for the start of a wedge that is closed at
--   the left side, and diminuendo for the start of a wedge that is closed
--   on the right side. Spread values are measured in tenths; those at the
--   start of a crescendo wedge or end of a diminuendo wedge are ignored.
--   The niente attribute is yes if a circle appears at the point of the
--   wedge, indicating a crescendo from nothing or diminuendo to nothing.
--   It is no by default, and used only when the type is crescendo, or the
--   type is stop for a wedge that began with a diminuendo type. The
--   line-type is solid by default.
data Wedge
Wedge :: WedgeType -> Maybe NumberLevel -> Maybe Tenths -> Maybe YesNo -> Maybe LineType -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Tenths -> Maybe Color -> Maybe ID -> Wedge

-- | <i>type</i> attribute
[wedgeType] :: Wedge -> WedgeType

-- | <i>number</i> attribute
[wedgeNumber] :: Wedge -> Maybe NumberLevel

-- | <i>spread</i> attribute
[wedgeSpread] :: Wedge -> Maybe Tenths

-- | <i>niente</i> attribute
[wedgeNiente] :: Wedge -> Maybe YesNo

-- | <i>line-type</i> attribute
[wedgeLineType] :: Wedge -> Maybe LineType

-- | <i>dash-length</i> attribute
[wedgeDashLength] :: Wedge -> Maybe Tenths

-- | <i>space-length</i> attribute
[wedgeSpaceLength] :: Wedge -> Maybe Tenths

-- | <i>default-x</i> attribute
[wedgeDefaultX] :: Wedge -> Maybe Tenths

-- | <i>default-y</i> attribute
[wedgeDefaultY] :: Wedge -> Maybe Tenths

-- | <i>relative-x</i> attribute
[wedgeRelativeX] :: Wedge -> Maybe Tenths

-- | <i>relative-y</i> attribute
[wedgeRelativeY] :: Wedge -> Maybe Tenths

-- | <i>color</i> attribute
[wedgeColor] :: Wedge -> Maybe Color

-- | <i>id</i> attribute
[wedgeId] :: Wedge -> Maybe ID
parseWedge :: XParse Wedge

-- | Smart constructor for <a>Wedge</a>
mkWedge :: WedgeType -> Wedge

-- | <tt>work</tt> <i>(complex)</i>
--   
--   Works are optionally identified by number and title. The work type
--   also may indicate a link to the opus document that composes multiple
--   scores into a collection.
data Work
Work :: Maybe String -> Maybe String -> Maybe Opus -> Work

-- | <i>work-number</i> child element
[workWorkNumber] :: Work -> Maybe String

-- | <i>work-title</i> child element
[workWorkTitle] :: Work -> Maybe String

-- | <i>opus</i> child element
[workOpus] :: Work -> Maybe Opus
parseWork :: XParse Work

-- | Smart constructor for <a>Work</a>
mkWork :: Work

-- | <tt>arrow</tt> <i>(choice)</i>
data ChxArrow
ArrowArrowDirection :: ArrowDirection -> Maybe ArrowStyle -> Maybe Empty -> ChxArrow

-- | <i>arrow-direction</i> child element
[arrowArrowDirection] :: ChxArrow -> ArrowDirection

-- | <i>arrow-style</i> child element
[arrowArrowStyle] :: ChxArrow -> Maybe ArrowStyle

-- | <i>arrowhead</i> child element
[arrowArrowhead] :: ChxArrow -> Maybe Empty
ArrowCircularArrow :: CircularArrow -> ChxArrow

-- | <i>circular-arrow</i> child element
[arrowCircularArrow] :: ChxArrow -> CircularArrow
parseChxArrow :: XParse ChxArrow

-- | Smart constructor for <a>ArrowArrowDirection</a>
mkArrowArrowDirection :: ArrowDirection -> ChxArrow

-- | Smart constructor for <a>ArrowCircularArrow</a>
mkArrowCircularArrow :: CircularArrow -> ChxArrow

-- | <tt>articulations</tt> <i>(choice)</i>
data ChxArticulations
ArticulationsAccent :: EmptyPlacement -> ChxArticulations

-- | <i>accent</i> child element
[articulationsAccent] :: ChxArticulations -> EmptyPlacement
ArticulationsStrongAccent :: StrongAccent -> ChxArticulations

-- | <i>strong-accent</i> child element
[articulationsStrongAccent] :: ChxArticulations -> StrongAccent
ArticulationsStaccato :: EmptyPlacement -> ChxArticulations

-- | <i>staccato</i> child element
[articulationsStaccato] :: ChxArticulations -> EmptyPlacement
ArticulationsTenuto :: EmptyPlacement -> ChxArticulations

-- | <i>tenuto</i> child element
[articulationsTenuto] :: ChxArticulations -> EmptyPlacement
ArticulationsDetachedLegato :: EmptyPlacement -> ChxArticulations

-- | <i>detached-legato</i> child element
[articulationsDetachedLegato] :: ChxArticulations -> EmptyPlacement
ArticulationsStaccatissimo :: EmptyPlacement -> ChxArticulations

-- | <i>staccatissimo</i> child element
[articulationsStaccatissimo] :: ChxArticulations -> EmptyPlacement
ArticulationsSpiccato :: EmptyPlacement -> ChxArticulations

-- | <i>spiccato</i> child element
[articulationsSpiccato] :: ChxArticulations -> EmptyPlacement
ArticulationsScoop :: EmptyLine -> ChxArticulations

-- | <i>scoop</i> child element
[articulationsScoop] :: ChxArticulations -> EmptyLine
ArticulationsPlop :: EmptyLine -> ChxArticulations

-- | <i>plop</i> child element
[articulationsPlop] :: ChxArticulations -> EmptyLine
ArticulationsDoit :: EmptyLine -> ChxArticulations

-- | <i>doit</i> child element
[articulationsDoit] :: ChxArticulations -> EmptyLine
ArticulationsFalloff :: EmptyLine -> ChxArticulations

-- | <i>falloff</i> child element
[articulationsFalloff] :: ChxArticulations -> EmptyLine
ArticulationsBreathMark :: BreathMark -> ChxArticulations

-- | <i>breath-mark</i> child element
[articulationsBreathMark] :: ChxArticulations -> BreathMark
ArticulationsCaesura :: Caesura -> ChxArticulations

-- | <i>caesura</i> child element
[articulationsCaesura] :: ChxArticulations -> Caesura
ArticulationsStress :: EmptyPlacement -> ChxArticulations

-- | <i>stress</i> child element
[articulationsStress] :: ChxArticulations -> EmptyPlacement
ArticulationsUnstress :: EmptyPlacement -> ChxArticulations

-- | <i>unstress</i> child element
[articulationsUnstress] :: ChxArticulations -> EmptyPlacement
ArticulationsSoftAccent :: EmptyPlacement -> ChxArticulations

-- | <i>soft-accent</i> child element
[articulationsSoftAccent] :: ChxArticulations -> EmptyPlacement
ArticulationsOtherArticulation :: OtherPlacementText -> ChxArticulations

-- | <i>other-articulation</i> child element
[articulationsOtherArticulation] :: ChxArticulations -> OtherPlacementText
parseChxArticulations :: XParse ChxArticulations

-- | Smart constructor for <a>ArticulationsAccent</a>
mkArticulationsAccent :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsStrongAccent</a>
mkArticulationsStrongAccent :: StrongAccent -> ChxArticulations

-- | Smart constructor for <a>ArticulationsStaccato</a>
mkArticulationsStaccato :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsTenuto</a>
mkArticulationsTenuto :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsDetachedLegato</a>
mkArticulationsDetachedLegato :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsStaccatissimo</a>
mkArticulationsStaccatissimo :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsSpiccato</a>
mkArticulationsSpiccato :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsScoop</a>
mkArticulationsScoop :: EmptyLine -> ChxArticulations

-- | Smart constructor for <a>ArticulationsPlop</a>
mkArticulationsPlop :: EmptyLine -> ChxArticulations

-- | Smart constructor for <a>ArticulationsDoit</a>
mkArticulationsDoit :: EmptyLine -> ChxArticulations

-- | Smart constructor for <a>ArticulationsFalloff</a>
mkArticulationsFalloff :: EmptyLine -> ChxArticulations

-- | Smart constructor for <a>ArticulationsBreathMark</a>
mkArticulationsBreathMark :: BreathMark -> ChxArticulations

-- | Smart constructor for <a>ArticulationsCaesura</a>
mkArticulationsCaesura :: Caesura -> ChxArticulations

-- | Smart constructor for <a>ArticulationsStress</a>
mkArticulationsStress :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsUnstress</a>
mkArticulationsUnstress :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsSoftAccent</a>
mkArticulationsSoftAccent :: EmptyPlacement -> ChxArticulations

-- | Smart constructor for <a>ArticulationsOtherArticulation</a>
mkArticulationsOtherArticulation :: OtherPlacementText -> ChxArticulations

-- | <tt>bend</tt> <i>(choice)</i>
data ChxBend
BendPreBend :: Empty -> ChxBend

-- | <i>pre-bend</i> child element
[bendPreBend] :: ChxBend -> Empty
BendRelease :: Empty -> ChxBend

-- | <i>release</i> child element
[bendRelease] :: ChxBend -> Empty
parseChxBend :: XParse ChxBend

-- | Smart constructor for <a>BendPreBend</a>
mkBendPreBend :: Empty -> ChxBend

-- | Smart constructor for <a>BendRelease</a>
mkBendRelease :: Empty -> ChxBend

-- | <tt>credit</tt> <i>(choice)</i>
data ChxCredit0
CreditCreditWords :: FormattedTextId -> ChxCredit0

-- | <i>credit-words</i> child element
[creditCreditWords] :: ChxCredit0 -> FormattedTextId
CreditCreditSymbol :: FormattedSymbolId -> ChxCredit0

-- | <i>credit-symbol</i> child element
[creditCreditSymbol] :: ChxCredit0 -> FormattedSymbolId
parseChxCredit0 :: XParse ChxCredit0

-- | Smart constructor for <a>CreditCreditWords</a>
mkCreditCreditWords :: FormattedTextId -> ChxCredit0

-- | Smart constructor for <a>CreditCreditSymbol</a>
mkCreditCreditSymbol :: FormattedSymbolId -> ChxCredit0

-- | <tt>credit</tt> <i>(choice)</i>
data ChxCredit1
ChxCreditCreditWords :: FormattedTextId -> ChxCredit1

-- | <i>credit-words</i> child element
[chxcreditCreditWords] :: ChxCredit1 -> FormattedTextId
ChxCreditCreditSymbol :: FormattedSymbolId -> ChxCredit1

-- | <i>credit-symbol</i> child element
[chxcreditCreditSymbol] :: ChxCredit1 -> FormattedSymbolId
parseChxCredit1 :: XParse ChxCredit1

-- | Smart constructor for <a>ChxCreditCreditWords</a>
mkChxCreditCreditWords :: FormattedTextId -> ChxCredit1

-- | Smart constructor for <a>ChxCreditCreditSymbol</a>
mkChxCreditCreditSymbol :: FormattedSymbolId -> ChxCredit1

-- | <tt>credit</tt> <i>(choice)</i>
data ChxCredit
CreditCreditImage :: Image -> ChxCredit

-- | <i>credit-image</i> child element
[creditCreditImage] :: ChxCredit -> Image
CreditCredit :: ChxCredit0 -> [SeqCredit] -> ChxCredit
[chxcreditCredit] :: ChxCredit -> ChxCredit0
[creditCredit1] :: ChxCredit -> [SeqCredit]
parseChxCredit :: XParse ChxCredit

-- | Smart constructor for <a>CreditCreditImage</a>
mkCreditCreditImage :: Image -> ChxCredit

-- | Smart constructor for <a>CreditCredit</a>
mkCreditCredit :: ChxCredit0 -> ChxCredit

-- | <tt>direction-type</tt> <i>(choice)</i>
data ChxDirectionType0
DirectionTypeWords :: FormattedTextId -> ChxDirectionType0

-- | <i>words</i> child element
[directionTypeWords] :: ChxDirectionType0 -> FormattedTextId
DirectionTypeSymbol :: FormattedSymbolId -> ChxDirectionType0

-- | <i>symbol</i> child element
[directionTypeSymbol] :: ChxDirectionType0 -> FormattedSymbolId
parseChxDirectionType0 :: XParse ChxDirectionType0

-- | Smart constructor for <a>DirectionTypeWords</a>
mkDirectionTypeWords :: FormattedTextId -> ChxDirectionType0

-- | Smart constructor for <a>DirectionTypeSymbol</a>
mkDirectionTypeSymbol :: FormattedSymbolId -> ChxDirectionType0

-- | <tt>direction-type</tt> <i>(choice)</i>
data ChxDirectionType
DirectionTypeRehearsal :: [FormattedTextId] -> ChxDirectionType

-- | <i>rehearsal</i> child element
[directionTypeRehearsal] :: ChxDirectionType -> [FormattedTextId]
DirectionTypeSegno :: [Segno] -> ChxDirectionType

-- | <i>segno</i> child element
[directionTypeSegno] :: ChxDirectionType -> [Segno]
DirectionTypeCoda :: [Coda] -> ChxDirectionType

-- | <i>coda</i> child element
[directionTypeCoda] :: ChxDirectionType -> [Coda]
DirectionTypeDirectionType :: [ChxDirectionType0] -> ChxDirectionType
[chxdirectionTypeDirectionType] :: ChxDirectionType -> [ChxDirectionType0]
DirectionTypeWedge :: Wedge -> ChxDirectionType

-- | <i>wedge</i> child element
[directionTypeWedge] :: ChxDirectionType -> Wedge
DirectionTypeDynamics :: [Dynamics] -> ChxDirectionType

-- | <i>dynamics</i> child element
[directionTypeDynamics] :: ChxDirectionType -> [Dynamics]
DirectionTypeDashes :: Dashes -> ChxDirectionType

-- | <i>dashes</i> child element
[directionTypeDashes] :: ChxDirectionType -> Dashes
DirectionTypeBracket :: Bracket -> ChxDirectionType

-- | <i>bracket</i> child element
[directionTypeBracket] :: ChxDirectionType -> Bracket
DirectionTypePedal :: Pedal -> ChxDirectionType

-- | <i>pedal</i> child element
[directionTypePedal] :: ChxDirectionType -> Pedal
DirectionTypeMetronome :: Metronome -> ChxDirectionType

-- | <i>metronome</i> child element
[directionTypeMetronome] :: ChxDirectionType -> Metronome
DirectionTypeOctaveShift :: OctaveShift -> ChxDirectionType

-- | <i>octave-shift</i> child element
[directionTypeOctaveShift] :: ChxDirectionType -> OctaveShift
DirectionTypeHarpPedals :: HarpPedals -> ChxDirectionType

-- | <i>harp-pedals</i> child element
[directionTypeHarpPedals] :: ChxDirectionType -> HarpPedals
DirectionTypeDamp :: EmptyPrintStyleAlignId -> ChxDirectionType

-- | <i>damp</i> child element
[directionTypeDamp] :: ChxDirectionType -> EmptyPrintStyleAlignId
DirectionTypeDampAll :: EmptyPrintStyleAlignId -> ChxDirectionType

-- | <i>damp-all</i> child element
[directionTypeDampAll] :: ChxDirectionType -> EmptyPrintStyleAlignId
DirectionTypeEyeglasses :: EmptyPrintStyleAlignId -> ChxDirectionType

-- | <i>eyeglasses</i> child element
[directionTypeEyeglasses] :: ChxDirectionType -> EmptyPrintStyleAlignId
DirectionTypeStringMute :: StringMute -> ChxDirectionType

-- | <i>string-mute</i> child element
[directionTypeStringMute] :: ChxDirectionType -> StringMute
DirectionTypeScordatura :: Scordatura -> ChxDirectionType

-- | <i>scordatura</i> child element
[directionTypeScordatura] :: ChxDirectionType -> Scordatura
DirectionTypeImage :: Image -> ChxDirectionType

-- | <i>image</i> child element
[directionTypeImage] :: ChxDirectionType -> Image
DirectionTypePrincipalVoice :: PrincipalVoice -> ChxDirectionType

-- | <i>principal-voice</i> child element
[directionTypePrincipalVoice] :: ChxDirectionType -> PrincipalVoice
DirectionTypePercussion :: [Percussion] -> ChxDirectionType

-- | <i>percussion</i> child element
[directionTypePercussion] :: ChxDirectionType -> [Percussion]
DirectionTypeAccordionRegistration :: AccordionRegistration -> ChxDirectionType

-- | <i>accordion-registration</i> child element
[directionTypeAccordionRegistration] :: ChxDirectionType -> AccordionRegistration
DirectionTypeStaffDivide :: StaffDivide -> ChxDirectionType

-- | <i>staff-divide</i> child element
[directionTypeStaffDivide] :: ChxDirectionType -> StaffDivide
DirectionTypeOtherDirection :: OtherDirection -> ChxDirectionType

-- | <i>other-direction</i> child element
[directionTypeOtherDirection] :: ChxDirectionType -> OtherDirection
parseChxDirectionType :: XParse ChxDirectionType

-- | Smart constructor for <a>DirectionTypeRehearsal</a>
mkDirectionTypeRehearsal :: ChxDirectionType

-- | Smart constructor for <a>DirectionTypeSegno</a>
mkDirectionTypeSegno :: ChxDirectionType

-- | Smart constructor for <a>DirectionTypeCoda</a>
mkDirectionTypeCoda :: ChxDirectionType

-- | Smart constructor for <a>DirectionTypeDirectionType</a>
mkDirectionTypeDirectionType :: ChxDirectionType

-- | Smart constructor for <a>DirectionTypeWedge</a>
mkDirectionTypeWedge :: Wedge -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeDynamics</a>
mkDirectionTypeDynamics :: ChxDirectionType

-- | Smart constructor for <a>DirectionTypeDashes</a>
mkDirectionTypeDashes :: Dashes -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeBracket</a>
mkDirectionTypeBracket :: Bracket -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypePedal</a>
mkDirectionTypePedal :: Pedal -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeMetronome</a>
mkDirectionTypeMetronome :: Metronome -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeOctaveShift</a>
mkDirectionTypeOctaveShift :: OctaveShift -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeHarpPedals</a>
mkDirectionTypeHarpPedals :: HarpPedals -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeDamp</a>
mkDirectionTypeDamp :: EmptyPrintStyleAlignId -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeDampAll</a>
mkDirectionTypeDampAll :: EmptyPrintStyleAlignId -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeEyeglasses</a>
mkDirectionTypeEyeglasses :: EmptyPrintStyleAlignId -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeStringMute</a>
mkDirectionTypeStringMute :: StringMute -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeScordatura</a>
mkDirectionTypeScordatura :: Scordatura -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeImage</a>
mkDirectionTypeImage :: Image -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypePrincipalVoice</a>
mkDirectionTypePrincipalVoice :: PrincipalVoice -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypePercussion</a>
mkDirectionTypePercussion :: ChxDirectionType

-- | Smart constructor for <a>DirectionTypeAccordionRegistration</a>
mkDirectionTypeAccordionRegistration :: AccordionRegistration -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeStaffDivide</a>
mkDirectionTypeStaffDivide :: StaffDivide -> ChxDirectionType

-- | Smart constructor for <a>DirectionTypeOtherDirection</a>
mkDirectionTypeOtherDirection :: OtherDirection -> ChxDirectionType

-- | <tt>dynamics</tt> <i>(choice)</i>
data ChxDynamics
DynamicsP :: Empty -> ChxDynamics

-- | <i>p</i> child element
[dynamicsP] :: ChxDynamics -> Empty
DynamicsPp :: Empty -> ChxDynamics

-- | <i>pp</i> child element
[dynamicsPp] :: ChxDynamics -> Empty
DynamicsPpp :: Empty -> ChxDynamics

-- | <i>ppp</i> child element
[dynamicsPpp] :: ChxDynamics -> Empty
DynamicsPppp :: Empty -> ChxDynamics

-- | <i>pppp</i> child element
[dynamicsPppp] :: ChxDynamics -> Empty
DynamicsPpppp :: Empty -> ChxDynamics

-- | <i>ppppp</i> child element
[dynamicsPpppp] :: ChxDynamics -> Empty
DynamicsPppppp :: Empty -> ChxDynamics

-- | <i>pppppp</i> child element
[dynamicsPppppp] :: ChxDynamics -> Empty
DynamicsF :: Empty -> ChxDynamics

-- | <i>f</i> child element
[dynamicsF] :: ChxDynamics -> Empty
DynamicsFf :: Empty -> ChxDynamics

-- | <i>ff</i> child element
[dynamicsFf] :: ChxDynamics -> Empty
DynamicsFff :: Empty -> ChxDynamics

-- | <i>fff</i> child element
[dynamicsFff] :: ChxDynamics -> Empty
DynamicsFfff :: Empty -> ChxDynamics

-- | <i>ffff</i> child element
[dynamicsFfff] :: ChxDynamics -> Empty
DynamicsFffff :: Empty -> ChxDynamics

-- | <i>fffff</i> child element
[dynamicsFffff] :: ChxDynamics -> Empty
DynamicsFfffff :: Empty -> ChxDynamics

-- | <i>ffffff</i> child element
[dynamicsFfffff] :: ChxDynamics -> Empty
DynamicsMp :: Empty -> ChxDynamics

-- | <i>mp</i> child element
[dynamicsMp] :: ChxDynamics -> Empty
DynamicsMf :: Empty -> ChxDynamics

-- | <i>mf</i> child element
[dynamicsMf] :: ChxDynamics -> Empty
DynamicsSf :: Empty -> ChxDynamics

-- | <i>sf</i> child element
[dynamicsSf] :: ChxDynamics -> Empty
DynamicsSfp :: Empty -> ChxDynamics

-- | <i>sfp</i> child element
[dynamicsSfp] :: ChxDynamics -> Empty
DynamicsSfpp :: Empty -> ChxDynamics

-- | <i>sfpp</i> child element
[dynamicsSfpp] :: ChxDynamics -> Empty
DynamicsFp :: Empty -> ChxDynamics

-- | <i>fp</i> child element
[dynamicsFp] :: ChxDynamics -> Empty
DynamicsRf :: Empty -> ChxDynamics

-- | <i>rf</i> child element
[dynamicsRf] :: ChxDynamics -> Empty
DynamicsRfz :: Empty -> ChxDynamics

-- | <i>rfz</i> child element
[dynamicsRfz] :: ChxDynamics -> Empty
DynamicsSfz :: Empty -> ChxDynamics

-- | <i>sfz</i> child element
[dynamicsSfz] :: ChxDynamics -> Empty
DynamicsSffz :: Empty -> ChxDynamics

-- | <i>sffz</i> child element
[dynamicsSffz] :: ChxDynamics -> Empty
DynamicsFz :: Empty -> ChxDynamics

-- | <i>fz</i> child element
[dynamicsFz] :: ChxDynamics -> Empty
DynamicsN :: Empty -> ChxDynamics

-- | <i>n</i> child element
[dynamicsN] :: ChxDynamics -> Empty
DynamicsPf :: Empty -> ChxDynamics

-- | <i>pf</i> child element
[dynamicsPf] :: ChxDynamics -> Empty
DynamicsSfzp :: Empty -> ChxDynamics

-- | <i>sfzp</i> child element
[dynamicsSfzp] :: ChxDynamics -> Empty
DynamicsOtherDynamics :: OtherText -> ChxDynamics

-- | <i>other-dynamics</i> child element
[dynamicsOtherDynamics] :: ChxDynamics -> OtherText
parseChxDynamics :: XParse ChxDynamics

-- | Smart constructor for <a>DynamicsP</a>
mkDynamicsP :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsPp</a>
mkDynamicsPp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsPpp</a>
mkDynamicsPpp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsPppp</a>
mkDynamicsPppp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsPpppp</a>
mkDynamicsPpppp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsPppppp</a>
mkDynamicsPppppp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsF</a>
mkDynamicsF :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsFf</a>
mkDynamicsFf :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsFff</a>
mkDynamicsFff :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsFfff</a>
mkDynamicsFfff :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsFffff</a>
mkDynamicsFffff :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsFfffff</a>
mkDynamicsFfffff :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsMp</a>
mkDynamicsMp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsMf</a>
mkDynamicsMf :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsSf</a>
mkDynamicsSf :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsSfp</a>
mkDynamicsSfp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsSfpp</a>
mkDynamicsSfpp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsFp</a>
mkDynamicsFp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsRf</a>
mkDynamicsRf :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsRfz</a>
mkDynamicsRfz :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsSfz</a>
mkDynamicsSfz :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsSffz</a>
mkDynamicsSffz :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsFz</a>
mkDynamicsFz :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsN</a>
mkDynamicsN :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsPf</a>
mkDynamicsPf :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsSfzp</a>
mkDynamicsSfzp :: Empty -> ChxDynamics

-- | Smart constructor for <a>DynamicsOtherDynamics</a>
mkDynamicsOtherDynamics :: OtherText -> ChxDynamics

-- | <tt>encoding</tt> <i>(choice)</i>
data ChxEncoding
EncodingEncodingDate :: YyyyMmDd -> ChxEncoding

-- | <i>encoding-date</i> child element
[encodingEncodingDate] :: ChxEncoding -> YyyyMmDd
EncodingEncoder :: TypedText -> ChxEncoding

-- | <i>encoder</i> child element
[encodingEncoder] :: ChxEncoding -> TypedText
EncodingSoftware :: String -> ChxEncoding

-- | <i>software</i> child element
[encodingSoftware] :: ChxEncoding -> String
EncodingEncodingDescription :: String -> ChxEncoding

-- | <i>encoding-description</i> child element
[encodingEncodingDescription] :: ChxEncoding -> String
EncodingSupports :: Supports -> ChxEncoding

-- | <i>supports</i> child element
[encodingSupports] :: ChxEncoding -> Supports
parseChxEncoding :: XParse ChxEncoding

-- | Smart constructor for <a>EncodingEncodingDate</a>
mkEncodingEncodingDate :: YyyyMmDd -> ChxEncoding

-- | Smart constructor for <a>EncodingEncoder</a>
mkEncodingEncoder :: TypedText -> ChxEncoding

-- | Smart constructor for <a>EncodingSoftware</a>
mkEncodingSoftware :: String -> ChxEncoding

-- | Smart constructor for <a>EncodingEncodingDescription</a>
mkEncodingEncodingDescription :: String -> ChxEncoding

-- | Smart constructor for <a>EncodingSupports</a>
mkEncodingSupports :: Supports -> ChxEncoding

-- | <tt>full-note</tt> <i>(choice)</i>
data FullNote
FullNotePitch :: Pitch -> FullNote

-- | <i>pitch</i> child element
[fullNotePitch] :: FullNote -> Pitch
FullNoteUnpitched :: Unpitched -> FullNote

-- | <i>unpitched</i> child element
[fullNoteUnpitched] :: FullNote -> Unpitched
FullNoteRest :: Rest -> FullNote

-- | <i>rest</i> child element
[fullNoteRest] :: FullNote -> Rest
parseFullNote :: XParse FullNote

-- | Smart constructor for <a>FullNotePitch</a>
mkFullNotePitch :: Pitch -> FullNote

-- | Smart constructor for <a>FullNoteUnpitched</a>
mkFullNoteUnpitched :: Unpitched -> FullNote

-- | Smart constructor for <a>FullNoteRest</a>
mkFullNoteRest :: Rest -> FullNote

-- | <tt>harmonic</tt> <i>(choice)</i>
data ChxHarmonic
HarmonicNatural :: Empty -> ChxHarmonic

-- | <i>natural</i> child element
[harmonicNatural] :: ChxHarmonic -> Empty
HarmonicArtificial :: Empty -> ChxHarmonic

-- | <i>artificial</i> child element
[harmonicArtificial] :: ChxHarmonic -> Empty
parseChxHarmonic :: XParse ChxHarmonic

-- | Smart constructor for <a>HarmonicNatural</a>
mkHarmonicNatural :: Empty -> ChxHarmonic

-- | Smart constructor for <a>HarmonicArtificial</a>
mkHarmonicArtificial :: Empty -> ChxHarmonic

-- | <tt>harmonic</tt> <i>(choice)</i>
data ChxHarmonic1
HarmonicBasePitch :: Empty -> ChxHarmonic1

-- | <i>base-pitch</i> child element
[harmonicBasePitch] :: ChxHarmonic1 -> Empty
HarmonicTouchingPitch :: Empty -> ChxHarmonic1

-- | <i>touching-pitch</i> child element
[harmonicTouchingPitch] :: ChxHarmonic1 -> Empty
HarmonicSoundingPitch :: Empty -> ChxHarmonic1

-- | <i>sounding-pitch</i> child element
[harmonicSoundingPitch] :: ChxHarmonic1 -> Empty
parseChxHarmonic1 :: XParse ChxHarmonic1

-- | Smart constructor for <a>HarmonicBasePitch</a>
mkHarmonicBasePitch :: Empty -> ChxHarmonic1

-- | Smart constructor for <a>HarmonicTouchingPitch</a>
mkHarmonicTouchingPitch :: Empty -> ChxHarmonic1

-- | Smart constructor for <a>HarmonicSoundingPitch</a>
mkHarmonicSoundingPitch :: Empty -> ChxHarmonic1

-- | <tt>harmony-chord</tt> <i>(choice)</i>
data ChxHarmonyChord
HarmonyChordRoot :: Root -> ChxHarmonyChord

-- | <i>root</i> child element
[harmonyChordRoot] :: ChxHarmonyChord -> Root
HarmonyChordFunction :: StyleText -> ChxHarmonyChord

-- | <i>function</i> child element
[harmonyChordFunction] :: ChxHarmonyChord -> StyleText
parseChxHarmonyChord :: XParse ChxHarmonyChord

-- | Smart constructor for <a>HarmonyChordRoot</a>
mkHarmonyChordRoot :: Root -> ChxHarmonyChord

-- | Smart constructor for <a>HarmonyChordFunction</a>
mkHarmonyChordFunction :: StyleText -> ChxHarmonyChord

-- | <tt>key</tt> <i>(choice)</i>
data ChxKey
KeyTraditionalKey :: TraditionalKey -> ChxKey
[keyTraditionalKey] :: ChxKey -> TraditionalKey
KeyNonTraditionalKey :: [NonTraditionalKey] -> ChxKey
[keyNonTraditionalKey] :: ChxKey -> [NonTraditionalKey]
parseChxKey :: XParse ChxKey

-- | Smart constructor for <a>KeyTraditionalKey</a>
mkKeyTraditionalKey :: TraditionalKey -> ChxKey

-- | Smart constructor for <a>KeyNonTraditionalKey</a>
mkKeyNonTraditionalKey :: ChxKey

-- | <tt>lyric</tt> <i>(choice)</i>
data ChxLyric
LyricSyllabic :: Maybe Syllabic -> TextElementData -> [SeqLyric] -> Maybe Extend -> ChxLyric

-- | <i>syllabic</i> child element
[lyricSyllabic] :: ChxLyric -> Maybe Syllabic

-- | <i>text</i> child element
[lyricText] :: ChxLyric -> TextElementData
[chxlyricLyric] :: ChxLyric -> [SeqLyric]

-- | <i>extend</i> child element
[lyricExtend] :: ChxLyric -> Maybe Extend
LyricExtend :: Extend -> ChxLyric

-- | <i>extend</i> child element
[lyricExtend1] :: ChxLyric -> Extend
LyricLaughing :: Empty -> ChxLyric

-- | <i>laughing</i> child element
[lyricLaughing] :: ChxLyric -> Empty
LyricHumming :: Empty -> ChxLyric

-- | <i>humming</i> child element
[lyricHumming] :: ChxLyric -> Empty
parseChxLyric :: XParse ChxLyric

-- | Smart constructor for <a>LyricSyllabic</a>
mkLyricSyllabic :: TextElementData -> ChxLyric

-- | Smart constructor for <a>LyricExtend</a>
mkLyricExtend :: Extend -> ChxLyric

-- | Smart constructor for <a>LyricLaughing</a>
mkLyricLaughing :: Empty -> ChxLyric

-- | Smart constructor for <a>LyricHumming</a>
mkLyricHumming :: Empty -> ChxLyric

-- | <tt>measure-style</tt> <i>(choice)</i>
data ChxMeasureStyle
MeasureStyleMultipleRest :: MultipleRest -> ChxMeasureStyle

-- | <i>multiple-rest</i> child element
[measureStyleMultipleRest] :: ChxMeasureStyle -> MultipleRest
MeasureStyleMeasureRepeat :: MeasureRepeat -> ChxMeasureStyle

-- | <i>measure-repeat</i> child element
[measureStyleMeasureRepeat] :: ChxMeasureStyle -> MeasureRepeat
MeasureStyleBeatRepeat :: BeatRepeat -> ChxMeasureStyle

-- | <i>beat-repeat</i> child element
[measureStyleBeatRepeat] :: ChxMeasureStyle -> BeatRepeat
MeasureStyleSlash :: CmpSlash -> ChxMeasureStyle

-- | <i>slash</i> child element
[measureStyleSlash] :: ChxMeasureStyle -> CmpSlash
parseChxMeasureStyle :: XParse ChxMeasureStyle

-- | Smart constructor for <a>MeasureStyleMultipleRest</a>
mkMeasureStyleMultipleRest :: MultipleRest -> ChxMeasureStyle

-- | Smart constructor for <a>MeasureStyleMeasureRepeat</a>
mkMeasureStyleMeasureRepeat :: MeasureRepeat -> ChxMeasureStyle

-- | Smart constructor for <a>MeasureStyleBeatRepeat</a>
mkMeasureStyleBeatRepeat :: BeatRepeat -> ChxMeasureStyle

-- | Smart constructor for <a>MeasureStyleSlash</a>
mkMeasureStyleSlash :: CmpSlash -> ChxMeasureStyle

-- | <tt>metronome</tt> <i>(choice)</i>
data ChxMetronome0
MetronomePerMinute :: PerMinute -> ChxMetronome0

-- | <i>per-minute</i> child element
[metronomePerMinute] :: ChxMetronome0 -> PerMinute
MetronomeBeatUnit :: BeatUnit -> [BeatUnitTied] -> ChxMetronome0
[metronomeBeatUnit] :: ChxMetronome0 -> BeatUnit

-- | <i>beat-unit-tied</i> child element
[metronomeBeatUnitTied] :: ChxMetronome0 -> [BeatUnitTied]
parseChxMetronome0 :: XParse ChxMetronome0

-- | Smart constructor for <a>MetronomePerMinute</a>
mkMetronomePerMinute :: PerMinute -> ChxMetronome0

-- | Smart constructor for <a>MetronomeBeatUnit</a>
mkMetronomeBeatUnit :: BeatUnit -> ChxMetronome0

-- | <tt>metronome</tt> <i>(choice)</i>
data ChxMetronome
ChxMetronomeBeatUnit :: BeatUnit -> [BeatUnitTied] -> ChxMetronome0 -> ChxMetronome
[chxmetronomeBeatUnit] :: ChxMetronome -> BeatUnit

-- | <i>beat-unit-tied</i> child element
[chxmetronomeBeatUnitTied] :: ChxMetronome -> [BeatUnitTied]
[chxmetronomeMetronome] :: ChxMetronome -> ChxMetronome0
MetronomeMetronomeArrows :: Maybe Empty -> [MetronomeNote] -> Maybe SeqMetronome -> ChxMetronome

-- | <i>metronome-arrows</i> child element
[metronomeMetronomeArrows] :: ChxMetronome -> Maybe Empty

-- | <i>metronome-note</i> child element
[metronomeMetronomeNote] :: ChxMetronome -> [MetronomeNote]
[metronomeMetronome1] :: ChxMetronome -> Maybe SeqMetronome
parseChxMetronome :: XParse ChxMetronome

-- | Smart constructor for <a>ChxMetronomeBeatUnit</a>
mkChxMetronomeBeatUnit :: BeatUnit -> ChxMetronome0 -> ChxMetronome

-- | Smart constructor for <a>MetronomeMetronomeArrows</a>
mkMetronomeMetronomeArrows :: ChxMetronome

-- | <tt>music-data</tt> <i>(choice)</i>
data ChxMusicData
MusicDataNote :: Note -> ChxMusicData

-- | <i>note</i> child element
[musicDataNote] :: ChxMusicData -> Note
MusicDataBackup :: Backup -> ChxMusicData

-- | <i>backup</i> child element
[musicDataBackup] :: ChxMusicData -> Backup
MusicDataForward :: Forward -> ChxMusicData

-- | <i>forward</i> child element
[musicDataForward] :: ChxMusicData -> Forward
MusicDataDirection :: Direction -> ChxMusicData

-- | <i>direction</i> child element
[musicDataDirection] :: ChxMusicData -> Direction
MusicDataAttributes :: Attributes -> ChxMusicData

-- | <i>attributes</i> child element
[musicDataAttributes] :: ChxMusicData -> Attributes
MusicDataHarmony :: Harmony -> ChxMusicData

-- | <i>harmony</i> child element
[musicDataHarmony] :: ChxMusicData -> Harmony
MusicDataFiguredBass :: FiguredBass -> ChxMusicData

-- | <i>figured-bass</i> child element
[musicDataFiguredBass] :: ChxMusicData -> FiguredBass
MusicDataPrint :: Print -> ChxMusicData

-- | <i>print</i> child element
[musicDataPrint] :: ChxMusicData -> Print
MusicDataSound :: Sound -> ChxMusicData

-- | <i>sound</i> child element
[musicDataSound] :: ChxMusicData -> Sound
MusicDataBarline :: Barline -> ChxMusicData

-- | <i>barline</i> child element
[musicDataBarline] :: ChxMusicData -> Barline
MusicDataGrouping :: Grouping -> ChxMusicData

-- | <i>grouping</i> child element
[musicDataGrouping] :: ChxMusicData -> Grouping
MusicDataLink :: Link -> ChxMusicData

-- | <i>link</i> child element
[musicDataLink] :: ChxMusicData -> Link
MusicDataBookmark :: Bookmark -> ChxMusicData

-- | <i>bookmark</i> child element
[musicDataBookmark] :: ChxMusicData -> Bookmark
parseChxMusicData :: XParse ChxMusicData

-- | Smart constructor for <a>MusicDataNote</a>
mkMusicDataNote :: Note -> ChxMusicData

-- | Smart constructor for <a>MusicDataBackup</a>
mkMusicDataBackup :: Backup -> ChxMusicData

-- | Smart constructor for <a>MusicDataForward</a>
mkMusicDataForward :: Forward -> ChxMusicData

-- | Smart constructor for <a>MusicDataDirection</a>
mkMusicDataDirection :: Direction -> ChxMusicData

-- | Smart constructor for <a>MusicDataAttributes</a>
mkMusicDataAttributes :: Attributes -> ChxMusicData

-- | Smart constructor for <a>MusicDataHarmony</a>
mkMusicDataHarmony :: Harmony -> ChxMusicData

-- | Smart constructor for <a>MusicDataFiguredBass</a>
mkMusicDataFiguredBass :: FiguredBass -> ChxMusicData

-- | Smart constructor for <a>MusicDataPrint</a>
mkMusicDataPrint :: Print -> ChxMusicData

-- | Smart constructor for <a>MusicDataSound</a>
mkMusicDataSound :: Sound -> ChxMusicData

-- | Smart constructor for <a>MusicDataBarline</a>
mkMusicDataBarline :: Barline -> ChxMusicData

-- | Smart constructor for <a>MusicDataGrouping</a>
mkMusicDataGrouping :: Grouping -> ChxMusicData

-- | Smart constructor for <a>MusicDataLink</a>
mkMusicDataLink :: Link -> ChxMusicData

-- | Smart constructor for <a>MusicDataBookmark</a>
mkMusicDataBookmark :: Bookmark -> ChxMusicData

-- | <tt>name-display</tt> <i>(choice)</i>
data ChxNameDisplay
NameDisplayDisplayText :: FormattedText -> ChxNameDisplay

-- | <i>display-text</i> child element
[nameDisplayDisplayText] :: ChxNameDisplay -> FormattedText
NameDisplayAccidentalText :: AccidentalText -> ChxNameDisplay

-- | <i>accidental-text</i> child element
[nameDisplayAccidentalText] :: ChxNameDisplay -> AccidentalText
parseChxNameDisplay :: XParse ChxNameDisplay

-- | Smart constructor for <a>NameDisplayDisplayText</a>
mkNameDisplayDisplayText :: FormattedText -> ChxNameDisplay

-- | Smart constructor for <a>NameDisplayAccidentalText</a>
mkNameDisplayAccidentalText :: AccidentalText -> ChxNameDisplay

-- | <tt>notations</tt> <i>(choice)</i>
data ChxNotations
NotationsTied :: Tied -> ChxNotations

-- | <i>tied</i> child element
[notationsTied] :: ChxNotations -> Tied
NotationsSlur :: Slur -> ChxNotations

-- | <i>slur</i> child element
[notationsSlur] :: ChxNotations -> Slur
NotationsTuplet :: Tuplet -> ChxNotations

-- | <i>tuplet</i> child element
[notationsTuplet] :: ChxNotations -> Tuplet
NotationsGlissando :: Glissando -> ChxNotations

-- | <i>glissando</i> child element
[notationsGlissando] :: ChxNotations -> Glissando
NotationsSlide :: Slide -> ChxNotations

-- | <i>slide</i> child element
[notationsSlide] :: ChxNotations -> Slide
NotationsOrnaments :: Ornaments -> ChxNotations

-- | <i>ornaments</i> child element
[notationsOrnaments] :: ChxNotations -> Ornaments
NotationsTechnical :: Technical -> ChxNotations

-- | <i>technical</i> child element
[notationsTechnical] :: ChxNotations -> Technical
NotationsArticulations :: Articulations -> ChxNotations

-- | <i>articulations</i> child element
[notationsArticulations] :: ChxNotations -> Articulations
NotationsDynamics :: Dynamics -> ChxNotations

-- | <i>dynamics</i> child element
[notationsDynamics] :: ChxNotations -> Dynamics
NotationsFermata :: Fermata -> ChxNotations

-- | <i>fermata</i> child element
[notationsFermata] :: ChxNotations -> Fermata
NotationsArpeggiate :: Arpeggiate -> ChxNotations

-- | <i>arpeggiate</i> child element
[notationsArpeggiate] :: ChxNotations -> Arpeggiate
NotationsNonArpeggiate :: NonArpeggiate -> ChxNotations

-- | <i>non-arpeggiate</i> child element
[notationsNonArpeggiate] :: ChxNotations -> NonArpeggiate
NotationsAccidentalMark :: AccidentalMark -> ChxNotations

-- | <i>accidental-mark</i> child element
[notationsAccidentalMark] :: ChxNotations -> AccidentalMark
NotationsOtherNotation :: OtherNotation -> ChxNotations

-- | <i>other-notation</i> child element
[notationsOtherNotation] :: ChxNotations -> OtherNotation
parseChxNotations :: XParse ChxNotations

-- | Smart constructor for <a>NotationsTied</a>
mkNotationsTied :: Tied -> ChxNotations

-- | Smart constructor for <a>NotationsSlur</a>
mkNotationsSlur :: Slur -> ChxNotations

-- | Smart constructor for <a>NotationsTuplet</a>
mkNotationsTuplet :: Tuplet -> ChxNotations

-- | Smart constructor for <a>NotationsGlissando</a>
mkNotationsGlissando :: Glissando -> ChxNotations

-- | Smart constructor for <a>NotationsSlide</a>
mkNotationsSlide :: Slide -> ChxNotations

-- | Smart constructor for <a>NotationsOrnaments</a>
mkNotationsOrnaments :: Ornaments -> ChxNotations

-- | Smart constructor for <a>NotationsTechnical</a>
mkNotationsTechnical :: Technical -> ChxNotations

-- | Smart constructor for <a>NotationsArticulations</a>
mkNotationsArticulations :: Articulations -> ChxNotations

-- | Smart constructor for <a>NotationsDynamics</a>
mkNotationsDynamics :: Dynamics -> ChxNotations

-- | Smart constructor for <a>NotationsFermata</a>
mkNotationsFermata :: Fermata -> ChxNotations

-- | Smart constructor for <a>NotationsArpeggiate</a>
mkNotationsArpeggiate :: Arpeggiate -> ChxNotations

-- | Smart constructor for <a>NotationsNonArpeggiate</a>
mkNotationsNonArpeggiate :: NonArpeggiate -> ChxNotations

-- | Smart constructor for <a>NotationsAccidentalMark</a>
mkNotationsAccidentalMark :: AccidentalMark -> ChxNotations

-- | Smart constructor for <a>NotationsOtherNotation</a>
mkNotationsOtherNotation :: OtherNotation -> ChxNotations

-- | <tt>note</tt> <i>(choice)</i>
data ChxNote0
NoteFullNote :: GrpFullNote -> [Tie] -> ChxNote0
[noteFullNote] :: ChxNote0 -> GrpFullNote

-- | <i>tie</i> child element
[noteTie] :: ChxNote0 -> [Tie]
NoteCue :: Empty -> GrpFullNote -> ChxNote0

-- | <i>cue</i> child element
[noteCue] :: ChxNote0 -> Empty
[noteFullNote1] :: ChxNote0 -> GrpFullNote
parseChxNote0 :: XParse ChxNote0

-- | Smart constructor for <a>NoteFullNote</a>
mkNoteFullNote :: GrpFullNote -> ChxNote0

-- | Smart constructor for <a>NoteCue</a>
mkNoteCue :: Empty -> GrpFullNote -> ChxNote0

-- | <tt>note</tt> <i>(choice)</i>
data ChxNote
NoteGrace :: Grace -> ChxNote0 -> ChxNote

-- | <i>grace</i> child element
[noteGrace] :: ChxNote -> Grace
[chxnoteNote] :: ChxNote -> ChxNote0
ChxNoteCue :: Empty -> GrpFullNote -> Duration -> ChxNote

-- | <i>cue</i> child element
[chxnoteCue] :: ChxNote -> Empty
[chxnoteFullNote] :: ChxNote -> GrpFullNote
[noteDuration] :: ChxNote -> Duration
ChxNoteFullNote :: GrpFullNote -> Duration -> [Tie] -> ChxNote
[chxnoteFullNote1] :: ChxNote -> GrpFullNote
[noteDuration1] :: ChxNote -> Duration

-- | <i>tie</i> child element
[chxnoteTie] :: ChxNote -> [Tie]
parseChxNote :: XParse ChxNote

-- | Smart constructor for <a>NoteGrace</a>
mkNoteGrace :: Grace -> ChxNote0 -> ChxNote

-- | Smart constructor for <a>ChxNoteCue</a>
mkChxNoteCue :: Empty -> GrpFullNote -> Duration -> ChxNote

-- | Smart constructor for <a>ChxNoteFullNote</a>
mkChxNoteFullNote :: GrpFullNote -> Duration -> ChxNote

-- | <tt>notehead-text</tt> <i>(choice)</i>
data ChxNoteheadText
NoteheadTextDisplayText :: FormattedText -> ChxNoteheadText

-- | <i>display-text</i> child element
[noteheadTextDisplayText] :: ChxNoteheadText -> FormattedText
NoteheadTextAccidentalText :: AccidentalText -> ChxNoteheadText

-- | <i>accidental-text</i> child element
[noteheadTextAccidentalText] :: ChxNoteheadText -> AccidentalText
parseChxNoteheadText :: XParse ChxNoteheadText

-- | Smart constructor for <a>NoteheadTextDisplayText</a>
mkNoteheadTextDisplayText :: FormattedText -> ChxNoteheadText

-- | Smart constructor for <a>NoteheadTextAccidentalText</a>
mkNoteheadTextAccidentalText :: AccidentalText -> ChxNoteheadText

-- | <tt>ornaments</tt> <i>(choice)</i>
data ChxOrnaments
OrnamentsTrillMark :: EmptyTrillSound -> ChxOrnaments

-- | <i>trill-mark</i> child element
[ornamentsTrillMark] :: ChxOrnaments -> EmptyTrillSound
OrnamentsTurn :: HorizontalTurn -> ChxOrnaments

-- | <i>turn</i> child element
[ornamentsTurn] :: ChxOrnaments -> HorizontalTurn
OrnamentsDelayedTurn :: HorizontalTurn -> ChxOrnaments

-- | <i>delayed-turn</i> child element
[ornamentsDelayedTurn] :: ChxOrnaments -> HorizontalTurn
OrnamentsInvertedTurn :: HorizontalTurn -> ChxOrnaments

-- | <i>inverted-turn</i> child element
[ornamentsInvertedTurn] :: ChxOrnaments -> HorizontalTurn
OrnamentsDelayedInvertedTurn :: HorizontalTurn -> ChxOrnaments

-- | <i>delayed-inverted-turn</i> child element
[ornamentsDelayedInvertedTurn] :: ChxOrnaments -> HorizontalTurn
OrnamentsVerticalTurn :: EmptyTrillSound -> ChxOrnaments

-- | <i>vertical-turn</i> child element
[ornamentsVerticalTurn] :: ChxOrnaments -> EmptyTrillSound
OrnamentsInvertedVerticalTurn :: EmptyTrillSound -> ChxOrnaments

-- | <i>inverted-vertical-turn</i> child element
[ornamentsInvertedVerticalTurn] :: ChxOrnaments -> EmptyTrillSound
OrnamentsShake :: EmptyTrillSound -> ChxOrnaments

-- | <i>shake</i> child element
[ornamentsShake] :: ChxOrnaments -> EmptyTrillSound
OrnamentsWavyLine :: WavyLine -> ChxOrnaments

-- | <i>wavy-line</i> child element
[ornamentsWavyLine] :: ChxOrnaments -> WavyLine
OrnamentsMordent :: Mordent -> ChxOrnaments

-- | <i>mordent</i> child element
[ornamentsMordent] :: ChxOrnaments -> Mordent
OrnamentsInvertedMordent :: Mordent -> ChxOrnaments

-- | <i>inverted-mordent</i> child element
[ornamentsInvertedMordent] :: ChxOrnaments -> Mordent
OrnamentsSchleifer :: EmptyPlacement -> ChxOrnaments

-- | <i>schleifer</i> child element
[ornamentsSchleifer] :: ChxOrnaments -> EmptyPlacement
OrnamentsTremolo :: Tremolo -> ChxOrnaments

-- | <i>tremolo</i> child element
[ornamentsTremolo] :: ChxOrnaments -> Tremolo
OrnamentsHaydn :: EmptyTrillSound -> ChxOrnaments

-- | <i>haydn</i> child element
[ornamentsHaydn] :: ChxOrnaments -> EmptyTrillSound
OrnamentsOtherOrnament :: OtherPlacementText -> ChxOrnaments

-- | <i>other-ornament</i> child element
[ornamentsOtherOrnament] :: ChxOrnaments -> OtherPlacementText
parseChxOrnaments :: XParse ChxOrnaments

-- | Smart constructor for <a>OrnamentsTrillMark</a>
mkOrnamentsTrillMark :: EmptyTrillSound -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsTurn</a>
mkOrnamentsTurn :: HorizontalTurn -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsDelayedTurn</a>
mkOrnamentsDelayedTurn :: HorizontalTurn -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsInvertedTurn</a>
mkOrnamentsInvertedTurn :: HorizontalTurn -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsDelayedInvertedTurn</a>
mkOrnamentsDelayedInvertedTurn :: HorizontalTurn -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsVerticalTurn</a>
mkOrnamentsVerticalTurn :: EmptyTrillSound -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsInvertedVerticalTurn</a>
mkOrnamentsInvertedVerticalTurn :: EmptyTrillSound -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsShake</a>
mkOrnamentsShake :: EmptyTrillSound -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsWavyLine</a>
mkOrnamentsWavyLine :: WavyLine -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsMordent</a>
mkOrnamentsMordent :: Mordent -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsInvertedMordent</a>
mkOrnamentsInvertedMordent :: Mordent -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsSchleifer</a>
mkOrnamentsSchleifer :: EmptyPlacement -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsTremolo</a>
mkOrnamentsTremolo :: Tremolo -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsHaydn</a>
mkOrnamentsHaydn :: EmptyTrillSound -> ChxOrnaments

-- | Smart constructor for <a>OrnamentsOtherOrnament</a>
mkOrnamentsOtherOrnament :: OtherPlacementText -> ChxOrnaments

-- | <tt>part-list</tt> <i>(choice)</i>
data ChxPartList
PartListPartGroup :: GrpPartGroup -> ChxPartList
[chxpartListPartGroup] :: ChxPartList -> GrpPartGroup
PartListScorePart :: ScorePart -> ChxPartList
[chxpartListScorePart] :: ChxPartList -> ScorePart
parseChxPartList :: XParse ChxPartList

-- | Smart constructor for <a>PartListPartGroup</a>
mkPartListPartGroup :: GrpPartGroup -> ChxPartList

-- | Smart constructor for <a>PartListScorePart</a>
mkPartListScorePart :: ScorePart -> ChxPartList

-- | <tt>percussion</tt> <i>(choice)</i>
data ChxPercussion
PercussionGlass :: Glass -> ChxPercussion

-- | <i>glass</i> child element
[percussionGlass] :: ChxPercussion -> Glass
PercussionMetal :: Metal -> ChxPercussion

-- | <i>metal</i> child element
[percussionMetal] :: ChxPercussion -> Metal
PercussionWood :: Wood -> ChxPercussion

-- | <i>wood</i> child element
[percussionWood] :: ChxPercussion -> Wood
PercussionPitched :: Pitched -> ChxPercussion

-- | <i>pitched</i> child element
[percussionPitched] :: ChxPercussion -> Pitched
PercussionMembrane :: Membrane -> ChxPercussion

-- | <i>membrane</i> child element
[percussionMembrane] :: ChxPercussion -> Membrane
PercussionEffect :: Effect -> ChxPercussion

-- | <i>effect</i> child element
[percussionEffect] :: ChxPercussion -> Effect
PercussionTimpani :: Empty -> ChxPercussion

-- | <i>timpani</i> child element
[percussionTimpani] :: ChxPercussion -> Empty
PercussionBeater :: Beater -> ChxPercussion

-- | <i>beater</i> child element
[percussionBeater] :: ChxPercussion -> Beater
PercussionStick :: Stick -> ChxPercussion

-- | <i>stick</i> child element
[percussionStick] :: ChxPercussion -> Stick
PercussionStickLocation :: StickLocation -> ChxPercussion

-- | <i>stick-location</i> child element
[percussionStickLocation] :: ChxPercussion -> StickLocation
PercussionOtherPercussion :: OtherText -> ChxPercussion

-- | <i>other-percussion</i> child element
[percussionOtherPercussion] :: ChxPercussion -> OtherText
parseChxPercussion :: XParse ChxPercussion

-- | Smart constructor for <a>PercussionGlass</a>
mkPercussionGlass :: Glass -> ChxPercussion

-- | Smart constructor for <a>PercussionMetal</a>
mkPercussionMetal :: Metal -> ChxPercussion

-- | Smart constructor for <a>PercussionWood</a>
mkPercussionWood :: Wood -> ChxPercussion

-- | Smart constructor for <a>PercussionPitched</a>
mkPercussionPitched :: Pitched -> ChxPercussion

-- | Smart constructor for <a>PercussionMembrane</a>
mkPercussionMembrane :: Membrane -> ChxPercussion

-- | Smart constructor for <a>PercussionEffect</a>
mkPercussionEffect :: Effect -> ChxPercussion

-- | Smart constructor for <a>PercussionTimpani</a>
mkPercussionTimpani :: Empty -> ChxPercussion

-- | Smart constructor for <a>PercussionBeater</a>
mkPercussionBeater :: Beater -> ChxPercussion

-- | Smart constructor for <a>PercussionStick</a>
mkPercussionStick :: Stick -> ChxPercussion

-- | Smart constructor for <a>PercussionStickLocation</a>
mkPercussionStickLocation :: StickLocation -> ChxPercussion

-- | Smart constructor for <a>PercussionOtherPercussion</a>
mkPercussionOtherPercussion :: OtherText -> ChxPercussion

-- | <tt>play</tt> <i>(choice)</i>
data ChxPlay
PlayIpa :: String -> ChxPlay

-- | <i>ipa</i> child element
[playIpa] :: ChxPlay -> String
PlayMute :: Mute -> ChxPlay

-- | <i>mute</i> child element
[playMute] :: ChxPlay -> Mute
PlaySemiPitched :: SemiPitched -> ChxPlay

-- | <i>semi-pitched</i> child element
[playSemiPitched] :: ChxPlay -> SemiPitched
PlayOtherPlay :: OtherPlay -> ChxPlay

-- | <i>other-play</i> child element
[playOtherPlay] :: ChxPlay -> OtherPlay
parseChxPlay :: XParse ChxPlay

-- | Smart constructor for <a>PlayIpa</a>
mkPlayIpa :: String -> ChxPlay

-- | Smart constructor for <a>PlayMute</a>
mkPlayMute :: Mute -> ChxPlay

-- | Smart constructor for <a>PlaySemiPitched</a>
mkPlaySemiPitched :: SemiPitched -> ChxPlay

-- | Smart constructor for <a>PlayOtherPlay</a>
mkPlayOtherPlay :: OtherPlay -> ChxPlay

-- | <tt>score-instrument</tt> <i>(choice)</i>
data ChxScoreInstrument
ScoreInstrumentSolo :: Empty -> ChxScoreInstrument

-- | <i>solo</i> child element
[scoreInstrumentSolo] :: ChxScoreInstrument -> Empty
ScoreInstrumentEnsemble :: PositiveIntegerOrEmpty -> ChxScoreInstrument

-- | <i>ensemble</i> child element
[scoreInstrumentEnsemble] :: ChxScoreInstrument -> PositiveIntegerOrEmpty
parseChxScoreInstrument :: XParse ChxScoreInstrument

-- | Smart constructor for <a>ScoreInstrumentSolo</a>
mkScoreInstrumentSolo :: Empty -> ChxScoreInstrument

-- | Smart constructor for <a>ScoreInstrumentEnsemble</a>
mkScoreInstrumentEnsemble :: PositiveIntegerOrEmpty -> ChxScoreInstrument

-- | <tt>technical</tt> <i>(choice)</i>
data ChxTechnical
TechnicalUpBow :: EmptyPlacement -> ChxTechnical

-- | <i>up-bow</i> child element
[technicalUpBow] :: ChxTechnical -> EmptyPlacement
TechnicalDownBow :: EmptyPlacement -> ChxTechnical

-- | <i>down-bow</i> child element
[technicalDownBow] :: ChxTechnical -> EmptyPlacement
TechnicalHarmonic :: Harmonic -> ChxTechnical

-- | <i>harmonic</i> child element
[technicalHarmonic] :: ChxTechnical -> Harmonic
TechnicalOpenString :: EmptyPlacement -> ChxTechnical

-- | <i>open-string</i> child element
[technicalOpenString] :: ChxTechnical -> EmptyPlacement
TechnicalThumbPosition :: EmptyPlacement -> ChxTechnical

-- | <i>thumb-position</i> child element
[technicalThumbPosition] :: ChxTechnical -> EmptyPlacement
TechnicalFingering :: Fingering -> ChxTechnical

-- | <i>fingering</i> child element
[technicalFingering] :: ChxTechnical -> Fingering
TechnicalPluck :: PlacementText -> ChxTechnical

-- | <i>pluck</i> child element
[technicalPluck] :: ChxTechnical -> PlacementText
TechnicalDoubleTongue :: EmptyPlacement -> ChxTechnical

-- | <i>double-tongue</i> child element
[technicalDoubleTongue] :: ChxTechnical -> EmptyPlacement
TechnicalTripleTongue :: EmptyPlacement -> ChxTechnical

-- | <i>triple-tongue</i> child element
[technicalTripleTongue] :: ChxTechnical -> EmptyPlacement
TechnicalStopped :: EmptyPlacementSmufl -> ChxTechnical

-- | <i>stopped</i> child element
[technicalStopped] :: ChxTechnical -> EmptyPlacementSmufl
TechnicalSnapPizzicato :: EmptyPlacement -> ChxTechnical

-- | <i>snap-pizzicato</i> child element
[technicalSnapPizzicato] :: ChxTechnical -> EmptyPlacement
TechnicalFret :: Fret -> ChxTechnical

-- | <i>fret</i> child element
[technicalFret] :: ChxTechnical -> Fret
TechnicalString :: CmpString -> ChxTechnical

-- | <i>string</i> child element
[technicalString] :: ChxTechnical -> CmpString
TechnicalHammerOn :: HammerOnPullOff -> ChxTechnical

-- | <i>hammer-on</i> child element
[technicalHammerOn] :: ChxTechnical -> HammerOnPullOff
TechnicalPullOff :: HammerOnPullOff -> ChxTechnical

-- | <i>pull-off</i> child element
[technicalPullOff] :: ChxTechnical -> HammerOnPullOff
TechnicalBend :: Bend -> ChxTechnical

-- | <i>bend</i> child element
[technicalBend] :: ChxTechnical -> Bend
TechnicalTap :: Tap -> ChxTechnical

-- | <i>tap</i> child element
[technicalTap] :: ChxTechnical -> Tap
TechnicalHeel :: HeelToe -> ChxTechnical

-- | <i>heel</i> child element
[technicalHeel] :: ChxTechnical -> HeelToe
TechnicalToe :: HeelToe -> ChxTechnical

-- | <i>toe</i> child element
[technicalToe] :: ChxTechnical -> HeelToe
TechnicalFingernails :: EmptyPlacement -> ChxTechnical

-- | <i>fingernails</i> child element
[technicalFingernails] :: ChxTechnical -> EmptyPlacement
TechnicalHole :: Hole -> ChxTechnical

-- | <i>hole</i> child element
[technicalHole] :: ChxTechnical -> Hole
TechnicalArrow :: Arrow -> ChxTechnical

-- | <i>arrow</i> child element
[technicalArrow] :: ChxTechnical -> Arrow
TechnicalHandbell :: Handbell -> ChxTechnical

-- | <i>handbell</i> child element
[technicalHandbell] :: ChxTechnical -> Handbell
TechnicalBrassBend :: EmptyPlacement -> ChxTechnical

-- | <i>brass-bend</i> child element
[technicalBrassBend] :: ChxTechnical -> EmptyPlacement
TechnicalFlip :: EmptyPlacement -> ChxTechnical

-- | <i>flip</i> child element
[technicalFlip] :: ChxTechnical -> EmptyPlacement
TechnicalSmear :: EmptyPlacement -> ChxTechnical

-- | <i>smear</i> child element
[technicalSmear] :: ChxTechnical -> EmptyPlacement
TechnicalOpen :: EmptyPlacementSmufl -> ChxTechnical

-- | <i>open</i> child element
[technicalOpen] :: ChxTechnical -> EmptyPlacementSmufl
TechnicalHalfMuted :: EmptyPlacementSmufl -> ChxTechnical

-- | <i>half-muted</i> child element
[technicalHalfMuted] :: ChxTechnical -> EmptyPlacementSmufl
TechnicalHarmonMute :: HarmonMute -> ChxTechnical

-- | <i>harmon-mute</i> child element
[technicalHarmonMute] :: ChxTechnical -> HarmonMute
TechnicalGolpe :: EmptyPlacement -> ChxTechnical

-- | <i>golpe</i> child element
[technicalGolpe] :: ChxTechnical -> EmptyPlacement
TechnicalOtherTechnical :: OtherPlacementText -> ChxTechnical

-- | <i>other-technical</i> child element
[technicalOtherTechnical] :: ChxTechnical -> OtherPlacementText
parseChxTechnical :: XParse ChxTechnical

-- | Smart constructor for <a>TechnicalUpBow</a>
mkTechnicalUpBow :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalDownBow</a>
mkTechnicalDownBow :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalHarmonic</a>
mkTechnicalHarmonic :: Harmonic -> ChxTechnical

-- | Smart constructor for <a>TechnicalOpenString</a>
mkTechnicalOpenString :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalThumbPosition</a>
mkTechnicalThumbPosition :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalFingering</a>
mkTechnicalFingering :: Fingering -> ChxTechnical

-- | Smart constructor for <a>TechnicalPluck</a>
mkTechnicalPluck :: PlacementText -> ChxTechnical

-- | Smart constructor for <a>TechnicalDoubleTongue</a>
mkTechnicalDoubleTongue :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalTripleTongue</a>
mkTechnicalTripleTongue :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalStopped</a>
mkTechnicalStopped :: EmptyPlacementSmufl -> ChxTechnical

-- | Smart constructor for <a>TechnicalSnapPizzicato</a>
mkTechnicalSnapPizzicato :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalFret</a>
mkTechnicalFret :: Fret -> ChxTechnical

-- | Smart constructor for <a>TechnicalString</a>
mkTechnicalString :: CmpString -> ChxTechnical

-- | Smart constructor for <a>TechnicalHammerOn</a>
mkTechnicalHammerOn :: HammerOnPullOff -> ChxTechnical

-- | Smart constructor for <a>TechnicalPullOff</a>
mkTechnicalPullOff :: HammerOnPullOff -> ChxTechnical

-- | Smart constructor for <a>TechnicalBend</a>
mkTechnicalBend :: Bend -> ChxTechnical

-- | Smart constructor for <a>TechnicalTap</a>
mkTechnicalTap :: Tap -> ChxTechnical

-- | Smart constructor for <a>TechnicalHeel</a>
mkTechnicalHeel :: HeelToe -> ChxTechnical

-- | Smart constructor for <a>TechnicalToe</a>
mkTechnicalToe :: HeelToe -> ChxTechnical

-- | Smart constructor for <a>TechnicalFingernails</a>
mkTechnicalFingernails :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalHole</a>
mkTechnicalHole :: Hole -> ChxTechnical

-- | Smart constructor for <a>TechnicalArrow</a>
mkTechnicalArrow :: Arrow -> ChxTechnical

-- | Smart constructor for <a>TechnicalHandbell</a>
mkTechnicalHandbell :: Handbell -> ChxTechnical

-- | Smart constructor for <a>TechnicalBrassBend</a>
mkTechnicalBrassBend :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalFlip</a>
mkTechnicalFlip :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalSmear</a>
mkTechnicalSmear :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalOpen</a>
mkTechnicalOpen :: EmptyPlacementSmufl -> ChxTechnical

-- | Smart constructor for <a>TechnicalHalfMuted</a>
mkTechnicalHalfMuted :: EmptyPlacementSmufl -> ChxTechnical

-- | Smart constructor for <a>TechnicalHarmonMute</a>
mkTechnicalHarmonMute :: HarmonMute -> ChxTechnical

-- | Smart constructor for <a>TechnicalGolpe</a>
mkTechnicalGolpe :: EmptyPlacement -> ChxTechnical

-- | Smart constructor for <a>TechnicalOtherTechnical</a>
mkTechnicalOtherTechnical :: OtherPlacementText -> ChxTechnical

-- | <tt>time</tt> <i>(choice)</i>
data ChxTime
TimeTimeSignature :: [TimeSignature] -> Maybe Interchangeable -> ChxTime
[timeTimeSignature] :: ChxTime -> [TimeSignature]

-- | <i>interchangeable</i> child element
[timeInterchangeable] :: ChxTime -> Maybe Interchangeable
TimeSenzaMisura :: String -> ChxTime

-- | <i>senza-misura</i> child element
[timeSenzaMisura] :: ChxTime -> String
parseChxTime :: XParse ChxTime

-- | Smart constructor for <a>TimeTimeSignature</a>
mkTimeTimeSignature :: ChxTime

-- | Smart constructor for <a>TimeSenzaMisura</a>
mkTimeSenzaMisura :: String -> ChxTime

-- | <tt>credit</tt> <i>(sequence)</i>
data SeqCredit
SeqCredit :: [Link] -> [Bookmark] -> ChxCredit1 -> SeqCredit

-- | <i>link</i> child element
[seqcreditLink] :: SeqCredit -> [Link]

-- | <i>bookmark</i> child element
[seqcreditBookmark] :: SeqCredit -> [Bookmark]
[seqcreditCredit] :: SeqCredit -> ChxCredit1
parseSeqCredit :: XParse SeqCredit

-- | Smart constructor for <a>SeqCredit</a>
mkSeqCredit :: ChxCredit1 -> SeqCredit

-- | <tt>lyric</tt> <i>(sequence)</i>
data SeqLyric0
SeqLyric0 :: Elision -> Maybe Syllabic -> SeqLyric0

-- | <i>elision</i> child element
[lyricElision] :: SeqLyric0 -> Elision

-- | <i>syllabic</i> child element
[seqlyricSyllabic] :: SeqLyric0 -> Maybe Syllabic
parseSeqLyric0 :: XParse SeqLyric0

-- | Smart constructor for <a>SeqLyric0</a>
mkSeqLyric0 :: Elision -> SeqLyric0

-- | <tt>lyric</tt> <i>(sequence)</i>
data SeqLyric
SeqLyric :: Maybe SeqLyric0 -> TextElementData -> SeqLyric
[seqlyricLyric] :: SeqLyric -> Maybe SeqLyric0

-- | <i>text</i> child element
[seqlyricText] :: SeqLyric -> TextElementData
parseSeqLyric :: XParse SeqLyric

-- | Smart constructor for <a>SeqLyric</a>
mkSeqLyric :: TextElementData -> SeqLyric

-- | <tt>metronome</tt> <i>(sequence)</i>
data SeqMetronome
SeqMetronome :: String -> [MetronomeNote] -> SeqMetronome

-- | <i>metronome-relation</i> child element
[metronomeMetronomeRelation] :: SeqMetronome -> String

-- | <i>metronome-note</i> child element
[seqmetronomeMetronomeNote] :: SeqMetronome -> [MetronomeNote]
parseSeqMetronome :: XParse SeqMetronome

-- | Smart constructor for <a>SeqMetronome</a>
mkSeqMetronome :: String -> SeqMetronome

-- | <tt>metronome-tuplet</tt> <i>(sequence)</i>
data SeqMetronomeTuplet
SeqMetronomeTuplet :: NoteTypeValue -> [Empty] -> SeqMetronomeTuplet

-- | <i>normal-type</i> child element
[metronomeTupletNormalType] :: SeqMetronomeTuplet -> NoteTypeValue

-- | <i>normal-dot</i> child element
[metronomeTupletNormalDot] :: SeqMetronomeTuplet -> [Empty]
parseSeqMetronomeTuplet :: XParse SeqMetronomeTuplet

-- | Smart constructor for <a>SeqMetronomeTuplet</a>
mkSeqMetronomeTuplet :: NoteTypeValue -> SeqMetronomeTuplet

-- | <tt>ornaments</tt> <i>(sequence)</i>
data SeqOrnaments
SeqOrnaments :: ChxOrnaments -> [AccidentalMark] -> SeqOrnaments
[seqornamentsOrnaments] :: SeqOrnaments -> ChxOrnaments

-- | <i>accidental-mark</i> child element
[ornamentsAccidentalMark] :: SeqOrnaments -> [AccidentalMark]
parseSeqOrnaments :: XParse SeqOrnaments

-- | Smart constructor for <a>SeqOrnaments</a>
mkSeqOrnaments :: ChxOrnaments -> SeqOrnaments

-- | <tt>page-layout</tt> <i>(sequence)</i>
data SeqPageLayout
SeqPageLayout :: Tenths -> Tenths -> SeqPageLayout

-- | <i>page-height</i> child element
[pageLayoutPageHeight] :: SeqPageLayout -> Tenths

-- | <i>page-width</i> child element
[pageLayoutPageWidth] :: SeqPageLayout -> Tenths
parseSeqPageLayout :: XParse SeqPageLayout

-- | Smart constructor for <a>SeqPageLayout</a>
mkSeqPageLayout :: Tenths -> Tenths -> SeqPageLayout

-- | <tt>score-part</tt> <i>(sequence)</i>
data SeqScorePart
SeqScorePart :: Maybe MidiDevice -> Maybe MidiInstrument -> SeqScorePart

-- | <i>midi-device</i> child element
[scorePartMidiDevice] :: SeqScorePart -> Maybe MidiDevice

-- | <i>midi-instrument</i> child element
[scorePartMidiInstrument] :: SeqScorePart -> Maybe MidiInstrument
parseSeqScorePart :: XParse SeqScorePart

-- | Smart constructor for <a>SeqScorePart</a>
mkSeqScorePart :: SeqScorePart

-- | <tt>slash</tt> <i>(sequence)</i>
data SeqSlash
SeqSlash :: NoteTypeValue -> [Empty] -> SeqSlash

-- | <i>slash-type</i> child element
[slashSlashType] :: SeqSlash -> NoteTypeValue

-- | <i>slash-dot</i> child element
[slashSlashDot] :: SeqSlash -> [Empty]
parseSeqSlash :: XParse SeqSlash

-- | Smart constructor for <a>SeqSlash</a>
mkSeqSlash :: NoteTypeValue -> SeqSlash

-- | <tt>sound</tt> <i>(sequence)</i>
data SeqSound
SeqSound :: Maybe MidiDevice -> Maybe MidiInstrument -> Maybe Play -> SeqSound

-- | <i>midi-device</i> child element
[soundMidiDevice] :: SeqSound -> Maybe MidiDevice

-- | <i>midi-instrument</i> child element
[soundMidiInstrument] :: SeqSound -> Maybe MidiInstrument

-- | <i>play</i> child element
[soundPlay] :: SeqSound -> Maybe Play
parseSeqSound :: XParse SeqSound

-- | Smart constructor for <a>SeqSound</a>
mkSeqSound :: SeqSound

-- | <tt>time-modification</tt> <i>(sequence)</i>
data SeqTimeModification
SeqTimeModification :: NoteTypeValue -> [Empty] -> SeqTimeModification

-- | <i>normal-type</i> child element
[timeModificationNormalType] :: SeqTimeModification -> NoteTypeValue

-- | <i>normal-dot</i> child element
[timeModificationNormalDot] :: SeqTimeModification -> [Empty]
parseSeqTimeModification :: XParse SeqTimeModification

-- | Smart constructor for <a>SeqTimeModification</a>
mkSeqTimeModification :: NoteTypeValue -> SeqTimeModification

-- | <tt>all-margins</tt> <i>(group)</i>
data AllMargins
AllMargins :: LeftRightMargins -> Tenths -> Tenths -> AllMargins
[allMarginsLeftRightMargins] :: AllMargins -> LeftRightMargins

-- | <i>top-margin</i> child element
[allMarginsTopMargin] :: AllMargins -> Tenths

-- | <i>bottom-margin</i> child element
[allMarginsBottomMargin] :: AllMargins -> Tenths
parseAllMargins :: XParse AllMargins

-- | Smart constructor for <a>AllMargins</a>
mkAllMargins :: LeftRightMargins -> Tenths -> Tenths -> AllMargins

-- | <tt>beat-unit</tt> <i>(group)</i>
data BeatUnit
BeatUnit :: NoteTypeValue -> [Empty] -> BeatUnit

-- | <i>beat-unit</i> child element
[beatUnitBeatUnit] :: BeatUnit -> NoteTypeValue

-- | <i>beat-unit-dot</i> child element
[beatUnitBeatUnitDot] :: BeatUnit -> [Empty]
parseBeatUnit :: XParse BeatUnit

-- | Smart constructor for <a>BeatUnit</a>
mkBeatUnit :: NoteTypeValue -> BeatUnit

-- | <tt>display-step-octave</tt> <i>(group)</i>
data DisplayStepOctave
DisplayStepOctave :: Step -> Octave -> DisplayStepOctave

-- | <i>display-step</i> child element
[displayStepOctaveDisplayStep] :: DisplayStepOctave -> Step

-- | <i>display-octave</i> child element
[displayStepOctaveDisplayOctave] :: DisplayStepOctave -> Octave
parseDisplayStepOctave :: XParse DisplayStepOctave

-- | Smart constructor for <a>DisplayStepOctave</a>
mkDisplayStepOctave :: Step -> Octave -> DisplayStepOctave

-- | <tt>duration</tt> <i>(group)</i>
data Duration
Duration :: PositiveDivisions -> Duration

-- | <i>duration</i> child element
[durationDuration] :: Duration -> PositiveDivisions
parseDuration :: XParse Duration

-- | Smart constructor for <a>Duration</a>
mkDuration :: PositiveDivisions -> Duration

-- | <tt>editorial</tt> <i>(group)</i>
data Editorial
Editorial :: Maybe Footnote -> Maybe GrpLevel -> Editorial
[editorialFootnote] :: Editorial -> Maybe Footnote
[editorialLevel] :: Editorial -> Maybe GrpLevel
parseEditorial :: XParse Editorial

-- | Smart constructor for <a>Editorial</a>
mkEditorial :: Editorial

-- | <tt>editorial-voice</tt> <i>(group)</i>
data EditorialVoice
EditorialVoice :: Maybe Footnote -> Maybe GrpLevel -> Maybe Voice -> EditorialVoice
[editorialVoiceFootnote] :: EditorialVoice -> Maybe Footnote
[editorialVoiceLevel] :: EditorialVoice -> Maybe GrpLevel
[editorialVoiceVoice] :: EditorialVoice -> Maybe Voice
parseEditorialVoice :: XParse EditorialVoice

-- | Smart constructor for <a>EditorialVoice</a>
mkEditorialVoice :: EditorialVoice

-- | <tt>editorial-voice-direction</tt> <i>(group)</i>
data EditorialVoiceDirection
EditorialVoiceDirection :: Maybe Footnote -> Maybe GrpLevel -> Maybe Voice -> EditorialVoiceDirection
[editorialVoiceDirectionFootnote] :: EditorialVoiceDirection -> Maybe Footnote
[editorialVoiceDirectionLevel] :: EditorialVoiceDirection -> Maybe GrpLevel
[editorialVoiceDirectionVoice] :: EditorialVoiceDirection -> Maybe Voice
parseEditorialVoiceDirection :: XParse EditorialVoiceDirection

-- | Smart constructor for <a>EditorialVoiceDirection</a>
mkEditorialVoiceDirection :: EditorialVoiceDirection

-- | <tt>footnote</tt> <i>(group)</i>
data Footnote
Footnote :: FormattedText -> Footnote

-- | <i>footnote</i> child element
[footnoteFootnote] :: Footnote -> FormattedText
parseFootnote :: XParse Footnote

-- | Smart constructor for <a>Footnote</a>
mkFootnote :: FormattedText -> Footnote

-- | <tt>full-note</tt> <i>(group)</i>
data GrpFullNote
GrpFullNote :: Maybe Empty -> FullNote -> GrpFullNote

-- | <i>chord</i> child element
[fullNoteChord] :: GrpFullNote -> Maybe Empty
[fullNoteFullNote] :: GrpFullNote -> FullNote
parseGrpFullNote :: XParse GrpFullNote

-- | Smart constructor for <a>GrpFullNote</a>
mkGrpFullNote :: FullNote -> GrpFullNote

-- | <tt>harmony-chord</tt> <i>(group)</i>
data HarmonyChord
HarmonyChord :: ChxHarmonyChord -> Kind -> Maybe Inversion -> Maybe Bass -> [Degree] -> HarmonyChord
[harmonyChordHarmonyChord] :: HarmonyChord -> ChxHarmonyChord

-- | <i>kind</i> child element
[harmonyChordKind] :: HarmonyChord -> Kind

-- | <i>inversion</i> child element
[harmonyChordInversion] :: HarmonyChord -> Maybe Inversion

-- | <i>bass</i> child element
[harmonyChordBass] :: HarmonyChord -> Maybe Bass

-- | <i>degree</i> child element
[harmonyChordDegree] :: HarmonyChord -> [Degree]
parseHarmonyChord :: XParse HarmonyChord

-- | Smart constructor for <a>HarmonyChord</a>
mkHarmonyChord :: ChxHarmonyChord -> Kind -> HarmonyChord

-- | <tt>layout</tt> <i>(group)</i>
data Layout
Layout :: Maybe PageLayout -> Maybe SystemLayout -> [StaffLayout] -> Layout

-- | <i>page-layout</i> child element
[layoutPageLayout] :: Layout -> Maybe PageLayout

-- | <i>system-layout</i> child element
[layoutSystemLayout] :: Layout -> Maybe SystemLayout

-- | <i>staff-layout</i> child element
[layoutStaffLayout] :: Layout -> [StaffLayout]
parseLayout :: XParse Layout

-- | Smart constructor for <a>Layout</a>
mkLayout :: Layout

-- | <tt>left-right-margins</tt> <i>(group)</i>
data LeftRightMargins
LeftRightMargins :: Tenths -> Tenths -> LeftRightMargins

-- | <i>left-margin</i> child element
[leftRightMarginsLeftMargin] :: LeftRightMargins -> Tenths

-- | <i>right-margin</i> child element
[leftRightMarginsRightMargin] :: LeftRightMargins -> Tenths
parseLeftRightMargins :: XParse LeftRightMargins

-- | Smart constructor for <a>LeftRightMargins</a>
mkLeftRightMargins :: Tenths -> Tenths -> LeftRightMargins

-- | <tt>level</tt> <i>(group)</i>
data GrpLevel
GrpLevel :: Level -> GrpLevel

-- | <i>level</i> child element
[levelLevel] :: GrpLevel -> Level
parseGrpLevel :: XParse GrpLevel

-- | Smart constructor for <a>GrpLevel</a>
mkGrpLevel :: Level -> GrpLevel

-- | <tt>music-data</tt> <i>(group)</i>
data MusicData
MusicData :: [ChxMusicData] -> MusicData
[musicDataMusicData] :: MusicData -> [ChxMusicData]
parseMusicData :: XParse MusicData

-- | Smart constructor for <a>MusicData</a>
mkMusicData :: MusicData

-- | <tt>non-traditional-key</tt> <i>(group)</i>
data NonTraditionalKey
NonTraditionalKey :: Step -> Semitones -> Maybe KeyAccidental -> NonTraditionalKey

-- | <i>key-step</i> child element
[nonTraditionalKeyKeyStep] :: NonTraditionalKey -> Step

-- | <i>key-alter</i> child element
[nonTraditionalKeyKeyAlter] :: NonTraditionalKey -> Semitones

-- | <i>key-accidental</i> child element
[nonTraditionalKeyKeyAccidental] :: NonTraditionalKey -> Maybe KeyAccidental
parseNonTraditionalKey :: XParse NonTraditionalKey

-- | Smart constructor for <a>NonTraditionalKey</a>
mkNonTraditionalKey :: Step -> Semitones -> NonTraditionalKey

-- | <tt>part-group</tt> <i>(group)</i>
data GrpPartGroup
GrpPartGroup :: PartGroup -> GrpPartGroup

-- | <i>part-group</i> child element
[partGroupPartGroup] :: GrpPartGroup -> PartGroup
parseGrpPartGroup :: XParse GrpPartGroup

-- | Smart constructor for <a>GrpPartGroup</a>
mkGrpPartGroup :: PartGroup -> GrpPartGroup

-- | <tt>score-header</tt> <i>(group)</i>
data ScoreHeader
ScoreHeader :: Maybe Work -> Maybe String -> Maybe String -> Maybe Identification -> Maybe Defaults -> [Credit] -> PartList -> ScoreHeader

-- | <i>work</i> child element
[scoreHeaderWork] :: ScoreHeader -> Maybe Work

-- | <i>movement-number</i> child element
[scoreHeaderMovementNumber] :: ScoreHeader -> Maybe String

-- | <i>movement-title</i> child element
[scoreHeaderMovementTitle] :: ScoreHeader -> Maybe String

-- | <i>identification</i> child element
[scoreHeaderIdentification] :: ScoreHeader -> Maybe Identification

-- | <i>defaults</i> child element
[scoreHeaderDefaults] :: ScoreHeader -> Maybe Defaults

-- | <i>credit</i> child element
[scoreHeaderCredit] :: ScoreHeader -> [Credit]

-- | <i>part-list</i> child element
[scoreHeaderPartList] :: ScoreHeader -> PartList
parseScoreHeader :: XParse ScoreHeader

-- | Smart constructor for <a>ScoreHeader</a>
mkScoreHeader :: PartList -> ScoreHeader

-- | <tt>score-part</tt> <i>(group)</i>
data ScorePart
ScorePart :: CmpScorePart -> ScorePart

-- | <i>score-part</i> child element
[grpscorePartScorePart] :: ScorePart -> CmpScorePart
parseScorePart :: XParse ScorePart

-- | Smart constructor for <a>ScorePart</a>
mkScorePart :: CmpScorePart -> ScorePart

-- | <tt>slash</tt> <i>(group)</i>
data Slash
Slash :: Maybe SeqSlash -> [String] -> Slash
[grpslashSlash] :: Slash -> Maybe SeqSlash

-- | <i>except-voice</i> child element
[slashExceptVoice] :: Slash -> [String]
parseSlash :: XParse Slash

-- | Smart constructor for <a>Slash</a>
mkSlash :: Slash

-- | <tt>staff</tt> <i>(group)</i>
data Staff
Staff :: PositiveInteger -> Staff

-- | <i>staff</i> child element
[staffStaff] :: Staff -> PositiveInteger
parseStaff :: XParse Staff

-- | Smart constructor for <a>Staff</a>
mkStaff :: PositiveInteger -> Staff

-- | <tt>time-signature</tt> <i>(group)</i>
data TimeSignature
TimeSignature :: String -> String -> TimeSignature

-- | <i>beats</i> child element
[timeSignatureBeats] :: TimeSignature -> String

-- | <i>beat-type</i> child element
[timeSignatureBeatType] :: TimeSignature -> String
parseTimeSignature :: XParse TimeSignature

-- | Smart constructor for <a>TimeSignature</a>
mkTimeSignature :: String -> String -> TimeSignature

-- | <tt>traditional-key</tt> <i>(group)</i>
data TraditionalKey
TraditionalKey :: Maybe Cancel -> Fifths -> Maybe Mode -> TraditionalKey

-- | <i>cancel</i> child element
[traditionalKeyCancel] :: TraditionalKey -> Maybe Cancel

-- | <i>fifths</i> child element
[traditionalKeyFifths] :: TraditionalKey -> Fifths

-- | <i>mode</i> child element
[traditionalKeyMode] :: TraditionalKey -> Maybe Mode
parseTraditionalKey :: XParse TraditionalKey

-- | Smart constructor for <a>TraditionalKey</a>
mkTraditionalKey :: Fifths -> TraditionalKey

-- | <tt>tuning</tt> <i>(group)</i>
data Tuning
Tuning :: Step -> Maybe Semitones -> Octave -> Tuning

-- | <i>tuning-step</i> child element
[tuningTuningStep] :: Tuning -> Step

-- | <i>tuning-alter</i> child element
[tuningTuningAlter] :: Tuning -> Maybe Semitones

-- | <i>tuning-octave</i> child element
[tuningTuningOctave] :: Tuning -> Octave
parseTuning :: XParse Tuning

-- | Smart constructor for <a>Tuning</a>
mkTuning :: Step -> Octave -> Tuning

-- | <tt>voice</tt> <i>(group)</i>
data Voice
Voice :: String -> Voice

-- | <i>voice</i> child element
[voiceVoice] :: Voice -> String
parseVoice :: XParse Voice

-- | Smart constructor for <a>Voice</a>
mkVoice :: String -> Voice
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.AboveBelow
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.AboveBelow
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.AboveBelow
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.AboveBelow
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.AboveBelow
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.AboveBelow
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.AccidentalValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.AccidentalValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.AccidentalValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.AccidentalValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.AccidentalValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.AccidentalValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Actuate
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Actuate
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Actuate
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Actuate
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Actuate
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Actuate
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.ArrowDirection
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.ArrowDirection
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.ArrowDirection
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ArrowDirection
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ArrowDirection
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ArrowDirection
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.ArrowStyle
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.ArrowStyle
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.ArrowStyle
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ArrowStyle
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ArrowStyle
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ArrowStyle
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.BackwardForward
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.BackwardForward
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.BackwardForward
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BackwardForward
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BackwardForward
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BackwardForward
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.BarStyle
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.BarStyle
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.BarStyle
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BarStyle
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BarStyle
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BarStyle
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.BeamValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.BeamValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.BeamValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BeamValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BeamValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BeamValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.BeaterValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.BeaterValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.BeaterValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BeaterValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BeaterValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BeaterValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.BreathMarkValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.BreathMarkValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.BreathMarkValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BreathMarkValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BreathMarkValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BreathMarkValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.CaesuraValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.CaesuraValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.CaesuraValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CaesuraValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CaesuraValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CaesuraValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.CancelLocation
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.CancelLocation
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.CancelLocation
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CancelLocation
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CancelLocation
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CancelLocation
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.CircularArrow
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.CircularArrow
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.CircularArrow
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CircularArrow
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CircularArrow
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CircularArrow
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.ClefSign
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.ClefSign
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.ClefSign
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ClefSign
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ClefSign
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ClefSign
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.CssFontSize
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.CssFontSize
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.CssFontSize
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CssFontSize
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CssFontSize
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CssFontSize
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.DegreeSymbolValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.DegreeSymbolValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.DegreeSymbolValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.DegreeSymbolValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.DegreeSymbolValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.DegreeSymbolValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.DegreeTypeValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.DegreeTypeValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.DegreeTypeValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.DegreeTypeValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.DegreeTypeValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.DegreeTypeValue
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.Divisions
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.Divisions
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Divisions
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Divisions
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Divisions
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Divisions
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Divisions
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Effect
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Effect
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Effect
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Effect
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Effect
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Effect
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.EnclosureShape
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.EnclosureShape
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.EnclosureShape
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EnclosureShape
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EnclosureShape
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EnclosureShape
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Fan
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Fan
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Fan
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Fan
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Fan
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Fan
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.FermataShape
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.FermataShape
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.FermataShape
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FermataShape
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FermataShape
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FermataShape
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FontSize
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FontSize
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FontSize
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.FontStyle
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.FontStyle
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.FontStyle
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FontStyle
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FontStyle
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FontStyle
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.FontWeight
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.FontWeight
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.FontWeight
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FontWeight
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FontWeight
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FontWeight
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.GlassValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.GlassValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.GlassValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GlassValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GlassValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GlassValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.GroupBarlineValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.GroupBarlineValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.GroupBarlineValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GroupBarlineValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GroupBarlineValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GroupBarlineValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.GroupSymbolValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.GroupSymbolValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.GroupSymbolValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GroupSymbolValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GroupSymbolValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GroupSymbolValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.HandbellValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.HandbellValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.HandbellValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HandbellValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HandbellValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HandbellValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.HarmonClosedLocation
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.HarmonClosedLocation
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.HarmonClosedLocation
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HarmonClosedLocation
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HarmonClosedLocation
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HarmonClosedLocation
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.HarmonClosedValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.HarmonClosedValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.HarmonClosedValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HarmonClosedValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HarmonClosedValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HarmonClosedValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.HarmonyType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.HarmonyType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.HarmonyType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HarmonyType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HarmonyType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HarmonyType
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.HoleClosedLocation
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.HoleClosedLocation
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.HoleClosedLocation
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HoleClosedLocation
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HoleClosedLocation
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HoleClosedLocation
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.HoleClosedValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.HoleClosedValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.HoleClosedValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HoleClosedValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HoleClosedValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HoleClosedValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.KindValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.KindValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.KindValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.KindValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.KindValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.KindValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.LeftCenterRight
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.LeftCenterRight
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.LeftCenterRight
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LeftCenterRight
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LeftCenterRight
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LeftCenterRight
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.LeftRight
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.LeftRight
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.LeftRight
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LeftRight
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LeftRight
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LeftRight
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.LineEnd
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.LineEnd
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.LineEnd
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LineEnd
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LineEnd
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LineEnd
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.LineLength
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.LineLength
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.LineLength
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LineLength
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LineLength
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LineLength
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.LineShape
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.LineShape
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.LineShape
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LineShape
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LineShape
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LineShape
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.LineType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.LineType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.LineType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LineType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LineType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LineType
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.MarginType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.MarginType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.MarginType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MarginType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MarginType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MarginType
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.MeasureNumberingValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.MeasureNumberingValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.MeasureNumberingValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MeasureNumberingValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MeasureNumberingValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MeasureNumberingValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Membrane
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Membrane
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Membrane
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Membrane
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Membrane
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Membrane
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Metal
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Metal
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Metal
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Metal
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Metal
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Metal
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.Millimeters
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.Millimeters
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Millimeters
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Millimeters
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Millimeters
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Millimeters
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Millimeters
instance Data.String.IsString Fadno.MusicXml.MusicXml31.Mode
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Mode
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Mode
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Mode
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Mute
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Mute
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Mute
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Mute
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Mute
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Mute
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance Data.String.IsString Fadno.MusicXml.MusicXml31.NormalizedString
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NormalizedString
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NormalizedString
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NormalizedString
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.NoteSizeType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.NoteSizeType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NoteSizeType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NoteSizeType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NoteSizeType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NoteSizeType
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.NoteTypeValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.NoteTypeValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NoteTypeValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NoteTypeValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NoteTypeValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NoteTypeValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.NoteheadValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.NoteheadValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NoteheadValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NoteheadValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NoteheadValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NoteheadValue
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.Octave
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Octave
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Octave
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Octave
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Octave
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Octave
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Octave
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Octave
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.OnOff
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.OnOff
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.OnOff
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OnOff
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OnOff
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OnOff
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.OverUnder
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.OverUnder
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.OverUnder
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OverUnder
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OverUnder
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OverUnder
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.PedalType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.PedalType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.PedalType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PedalType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PedalType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PedalType
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.Percent
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.Percent
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Percent
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Percent
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Percent
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Percent
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Percent
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.PitchedValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.PitchedValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.PitchedValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PitchedValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PitchedValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PitchedValue
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.PositiveDivisions
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.PositiveDivisions
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.PositiveDivisions
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.PositiveDivisions
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.PositiveDivisions
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PositiveDivisions
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PositiveDivisions
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.PrincipalVoiceSymbol
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.PrincipalVoiceSymbol
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.PrincipalVoiceSymbol
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PrincipalVoiceSymbol
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PrincipalVoiceSymbol
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PrincipalVoiceSymbol
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.RightLeftMiddle
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.RightLeftMiddle
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.RightLeftMiddle
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.RightLeftMiddle
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.RightLeftMiddle
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.RightLeftMiddle
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.RotationDegrees
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.RotationDegrees
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.RotationDegrees
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.RotationDegrees
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.RotationDegrees
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.RotationDegrees
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.RotationDegrees
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.SemiPitched
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.SemiPitched
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SemiPitched
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SemiPitched
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SemiPitched
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SemiPitched
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.Semitones
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.Semitones
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Semitones
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Semitones
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Semitones
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Semitones
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Semitones
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.SmpShow
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.SmpShow
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SmpShow
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SmpShow
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SmpShow
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SmpShow
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.ShowFrets
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.ShowFrets
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.ShowFrets
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ShowFrets
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ShowFrets
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ShowFrets
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.ShowTuplet
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.ShowTuplet
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.ShowTuplet
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ShowTuplet
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ShowTuplet
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ShowTuplet
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Space
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Space
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Space
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Space
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Space
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Space
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StaffDivideSymbol
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StaffDivideSymbol
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StaffDivideSymbol
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StaffDivideSymbol
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StaffDivideSymbol
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StaffDivideSymbol
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StaffType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StaffType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StaffType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StaffType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StaffType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StaffType
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StartNote
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StartNote
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StartNote
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StartNote
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StartNote
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StartNote
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StartStop
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StartStop
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StartStop
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StartStop
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StartStop
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StartStop
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StartStopContinue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StartStopContinue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StartStopContinue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StartStopContinue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StartStopContinue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StartStopContinue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StartStopDiscontinue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StartStopDiscontinue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StartStopDiscontinue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StartStopDiscontinue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StartStopDiscontinue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StartStopDiscontinue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StartStopSingle
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StartStopSingle
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StartStopSingle
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StartStopSingle
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StartStopSingle
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StartStopSingle
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StemValue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StemValue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StemValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StemValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StemValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StemValue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Step
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Step
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Step
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Step
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Step
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Step
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StickLocation
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StickLocation
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StickLocation
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StickLocation
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StickLocation
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StickLocation
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StickMaterial
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StickMaterial
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StickMaterial
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StickMaterial
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StickMaterial
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StickMaterial
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StickType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StickType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StickType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StickType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StickType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StickType
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Syllabic
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Syllabic
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Syllabic
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Syllabic
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Syllabic
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Syllabic
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.SymbolSize
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.SymbolSize
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SymbolSize
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SymbolSize
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SymbolSize
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SymbolSize
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TapHand
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TapHand
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TapHand
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TapHand
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TapHand
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TapHand
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.Tenths
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.Tenths
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.Tenths
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.Tenths
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Tenths
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Tenths
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Tenths
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TextDirection
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TextDirection
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TextDirection
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TextDirection
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TextDirection
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TextDirection
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TiedType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TiedType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TiedType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TiedType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TiedType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TiedType
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TimeRelation
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TimeRelation
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TimeRelation
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TimeRelation
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TimeRelation
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TimeRelation
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TimeSeparator
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TimeSeparator
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TimeSeparator
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TimeSeparator
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TimeSeparator
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TimeSeparator
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TimeSymbol
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TimeSymbol
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TimeSymbol
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TimeSymbol
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TimeSymbol
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TimeSymbol
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TipDirection
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TipDirection
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TipDirection
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TipDirection
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TipDirection
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TipDirection
instance Data.String.IsString Fadno.MusicXml.MusicXml31.Token
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Token
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Token
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Token
instance Data.String.IsString Fadno.MusicXml.MusicXml31.TimeOnly
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TimeOnly
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TimeOnly
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TimeOnly
instance Data.String.IsString Fadno.MusicXml.MusicXml31.MeasureText
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.MeasureText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MeasureText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MeasureText
instance Data.String.IsString Fadno.MusicXml.MusicXml31.LineWidthType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.LineWidthType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LineWidthType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LineWidthType
instance Data.String.IsString Fadno.MusicXml.MusicXml31.Language
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Language
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Language
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Language
instance Data.String.IsString Fadno.MusicXml.MusicXml31.GlyphType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.GlyphType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GlyphType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GlyphType
instance Data.String.IsString Fadno.MusicXml.MusicXml31.EndingNumber
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.EndingNumber
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EndingNumber
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EndingNumber
instance Data.String.IsString Fadno.MusicXml.MusicXml31.DistanceType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.DistanceType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.DistanceType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.DistanceType
instance Data.String.IsString Fadno.MusicXml.MusicXml31.CommaSeparatedText
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.CommaSeparatedText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CommaSeparatedText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CommaSeparatedText
instance Data.String.IsString Fadno.MusicXml.MusicXml31.Color
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Color
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Color
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Color
instance Data.String.IsString Fadno.MusicXml.MusicXml31.Name
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Name
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Name
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Name
instance Data.String.IsString Fadno.MusicXml.MusicXml31.NCName
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NCName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NCName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NCName
instance Data.String.IsString Fadno.MusicXml.MusicXml31.IDREF
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.IDREF
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.IDREF
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.IDREF
instance Data.String.IsString Fadno.MusicXml.MusicXml31.ID
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.ID
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ID
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ID
instance Data.String.IsString Fadno.MusicXml.MusicXml31.NMTOKEN
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.NMTOKEN
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NMTOKEN
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NMTOKEN
instance Data.String.IsString Fadno.MusicXml.MusicXml31.SmuflGlyphName
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SmuflGlyphName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SmuflGlyphName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SmuflGlyphName
instance Data.String.IsString Fadno.MusicXml.MusicXml31.SmuflSegnoGlyphName
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SmuflSegnoGlyphName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SmuflSegnoGlyphName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SmuflSegnoGlyphName
instance Data.String.IsString Fadno.MusicXml.MusicXml31.SmuflPictogramGlyphName
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SmuflPictogramGlyphName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SmuflPictogramGlyphName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SmuflPictogramGlyphName
instance Data.String.IsString Fadno.MusicXml.MusicXml31.SmuflLyricsGlyphName
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SmuflLyricsGlyphName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SmuflLyricsGlyphName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SmuflLyricsGlyphName
instance Data.String.IsString Fadno.MusicXml.MusicXml31.SmuflCodaGlyphName
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SmuflCodaGlyphName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SmuflCodaGlyphName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SmuflCodaGlyphName
instance Data.String.IsString Fadno.MusicXml.MusicXml31.SmuflAccidentalGlyphName
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SmuflAccidentalGlyphName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SmuflAccidentalGlyphName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SmuflAccidentalGlyphName
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TopBottom
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TopBottom
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TopBottom
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TopBottom
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TopBottom
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TopBottom
instance GHC.Real.Integral Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TremoloType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TremoloType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TremoloType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TremoloType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TremoloType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TremoloType
instance GHC.Real.RealFrac Fadno.MusicXml.MusicXml31.TrillBeats
instance GHC.Real.Fractional Fadno.MusicXml.MusicXml31.TrillBeats
instance GHC.Real.Real Fadno.MusicXml.MusicXml31.TrillBeats
instance GHC.Num.Num Fadno.MusicXml.MusicXml31.TrillBeats
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TrillBeats
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TrillBeats
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TrillBeats
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TrillStep
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TrillStep
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TrillStep
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TrillStep
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TrillStep
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TrillStep
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.TwoNoteTurn
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.TwoNoteTurn
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.TwoNoteTurn
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TwoNoteTurn
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TwoNoteTurn
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TwoNoteTurn
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Type
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Type
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Type
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Type
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Type
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Type
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.UpDown
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.UpDown
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.UpDown
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.UpDown
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.UpDown
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.UpDown
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.UpDownStopContinue
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.UpDownStopContinue
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.UpDownStopContinue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.UpDownStopContinue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.UpDownStopContinue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.UpDownStopContinue
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.UprightInverted
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.UprightInverted
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.UprightInverted
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.UprightInverted
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.UprightInverted
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.UprightInverted
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Valign
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Valign
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Valign
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Valign
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Valign
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Valign
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.ValignImage
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.ValignImage
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.ValignImage
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ValignImage
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ValignImage
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ValignImage
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.WedgeType
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.WedgeType
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.WedgeType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.WedgeType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.WedgeType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.WedgeType
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Winged
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Winged
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Winged
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Winged
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Winged
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Winged
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.Wood
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.Wood
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.Wood
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Wood
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Wood
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Wood
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.YesNo
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.YesNo
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.YesNo
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.YesNo
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.YesNo
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.YesNo
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.YesNoNumber
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.YesNoNumber
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.YesNoNumber
instance Data.String.IsString Fadno.MusicXml.MusicXml31.YyyyMmDd
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.YyyyMmDd
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.YyyyMmDd
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.YyyyMmDd
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.SumLang
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.SumLang
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SumLang
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SumLang
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SumLang
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SumLang
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Lang
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Lang
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Lang
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.SumNumberOrNormal
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.SumNumberOrNormal
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SumNumberOrNormal
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SumNumberOrNormal
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SumNumberOrNormal
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SumNumberOrNormal
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NumberOrNormal
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NumberOrNormal
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NumberOrNormal
instance GHC.Enum.Bounded Fadno.MusicXml.MusicXml31.SumPositiveIntegerOrEmpty
instance GHC.Enum.Enum Fadno.MusicXml.MusicXml31.SumPositiveIntegerOrEmpty
instance GHC.Classes.Ord Fadno.MusicXml.MusicXml31.SumPositiveIntegerOrEmpty
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SumPositiveIntegerOrEmpty
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SumPositiveIntegerOrEmpty
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SumPositiveIntegerOrEmpty
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PositiveIntegerOrEmpty
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PositiveIntegerOrEmpty
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PositiveIntegerOrEmpty
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Accidental
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Accidental
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Accidental
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.AccidentalMark
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.AccidentalMark
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.AccidentalMark
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.AccidentalText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.AccidentalText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.AccidentalText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Arpeggiate
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Arpeggiate
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Arpeggiate
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BarStyleColor
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BarStyleColor
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BarStyleColor
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Barre
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Barre
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Barre
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BassAlter
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BassAlter
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BassAlter
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BassStep
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BassStep
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BassStep
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Bass
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Bass
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Bass
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Beam
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Beam
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Beam
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Beater
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Beater
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Beater
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Bookmark
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Bookmark
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Bookmark
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Bracket
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Bracket
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Bracket
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BreathMark
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BreathMark
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BreathMark
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Caesura
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Caesura
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Caesura
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Cancel
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Cancel
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Cancel
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Clef
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Clef
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Clef
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Coda
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Coda
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Coda
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Dashes
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Dashes
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Dashes
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.DegreeAlter
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.DegreeAlter
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.DegreeAlter
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.DegreeType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.DegreeType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.DegreeType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.DegreeValue
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.DegreeValue
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.DegreeValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Degree
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Degree
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Degree
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Directive
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Directive
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Directive
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Distance
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Distance
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Distance
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Elision
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Elision
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Elision
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Empty
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Empty
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Empty
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.AccordionRegistration
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.AccordionRegistration
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.AccordionRegistration
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EmptyFont
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EmptyFont
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EmptyFont
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EmptyLine
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EmptyLine
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EmptyLine
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EmptyPlacement
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EmptyPlacement
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EmptyPlacement
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EmptyPlacementSmufl
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EmptyPlacementSmufl
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EmptyPlacementSmufl
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EmptyPrintObjectStyleAlign
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EmptyPrintObjectStyleAlign
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EmptyPrintObjectStyleAlign
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EmptyPrintStyleAlignId
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EmptyPrintStyleAlignId
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EmptyPrintStyleAlignId
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EmptyTrillSound
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EmptyTrillSound
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EmptyTrillSound
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Ending
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Ending
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Ending
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Extend
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Extend
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Extend
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Feature
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Feature
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Feature
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Fermata
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Fermata
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Fermata
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Fingering
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Fingering
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Fingering
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FirstFret
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FirstFret
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FirstFret
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FormattedSymbolId
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FormattedSymbolId
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FormattedSymbolId
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FormattedText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FormattedText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FormattedText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FormattedTextId
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FormattedTextId
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FormattedTextId
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Fret
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Fret
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Fret
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Glass
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Glass
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Glass
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Glissando
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Glissando
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Glissando
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Glyph
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Glyph
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Glyph
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Grace
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Grace
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Grace
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GroupBarline
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GroupBarline
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GroupBarline
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GroupName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GroupName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GroupName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GroupSymbol
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GroupSymbol
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GroupSymbol
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Grouping
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Grouping
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Grouping
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HammerOnPullOff
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HammerOnPullOff
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HammerOnPullOff
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Handbell
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Handbell
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Handbell
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HarmonClosed
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HarmonClosed
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HarmonClosed
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HarmonMute
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HarmonMute
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HarmonMute
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HeelToe
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HeelToe
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HeelToe
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HoleClosed
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HoleClosed
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HoleClosed
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Hole
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Hole
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Hole
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HorizontalTurn
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HorizontalTurn
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HorizontalTurn
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Image
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Image
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Image
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Instrument
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Instrument
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Instrument
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Inversion
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Inversion
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Inversion
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.KeyAccidental
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.KeyAccidental
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.KeyAccidental
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.KeyOctave
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.KeyOctave
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.KeyOctave
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Kind
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Kind
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Kind
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Level
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Level
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Level
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LineWidth
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LineWidth
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LineWidth
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Link
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Link
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Link
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LyricFont
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LyricFont
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LyricFont
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LyricLanguage
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LyricLanguage
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LyricLanguage
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MeasureLayout
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MeasureLayout
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MeasureLayout
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MeasureNumbering
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MeasureNumbering
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MeasureNumbering
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MeasureRepeat
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MeasureRepeat
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MeasureRepeat
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MetronomeBeam
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MetronomeBeam
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MetronomeBeam
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MetronomeTied
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MetronomeTied
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MetronomeTied
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MetronomeTuplet
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MetronomeTuplet
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MetronomeTuplet
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MetronomeNote
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MetronomeNote
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MetronomeNote
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MidiDevice
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MidiDevice
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MidiDevice
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MidiInstrument
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MidiInstrument
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MidiInstrument
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MiscellaneousField
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MiscellaneousField
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MiscellaneousField
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Miscellaneous
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Miscellaneous
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Miscellaneous
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Mordent
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Mordent
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Mordent
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MultipleRest
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MultipleRest
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MultipleRest
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NonArpeggiate
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NonArpeggiate
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NonArpeggiate
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NoteSize
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NoteSize
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NoteSize
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NoteType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NoteType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NoteType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Notehead
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Notehead
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Notehead
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OctaveShift
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OctaveShift
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OctaveShift
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Offset
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Offset
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Offset
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Opus
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Opus
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Opus
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OtherAppearance
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OtherAppearance
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OtherAppearance
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Appearance
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Appearance
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Appearance
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OtherDirection
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OtherDirection
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OtherDirection
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OtherNotation
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OtherNotation
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OtherNotation
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OtherPlacementText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OtherPlacementText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OtherPlacementText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OtherPlay
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OtherPlay
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OtherPlay
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.OtherText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.OtherText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.OtherText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PartName
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PartName
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PartName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PartSymbol
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PartSymbol
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PartSymbol
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Pedal
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Pedal
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Pedal
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PedalTuning
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PedalTuning
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PedalTuning
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HarpPedals
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HarpPedals
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HarpPedals
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PerMinute
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PerMinute
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PerMinute
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Pitch
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Pitch
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Pitch
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Pitched
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Pitched
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Pitched
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PlacementText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PlacementText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PlacementText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PrincipalVoice
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PrincipalVoice
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PrincipalVoice
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Repeat
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Repeat
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Repeat
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.RootAlter
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.RootAlter
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.RootAlter
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.RootStep
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.RootStep
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.RootStep
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Root
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Root
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Root
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Scaling
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Scaling
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Scaling
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Segno
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Segno
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Segno
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Slide
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Slide
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Slide
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Slur
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Slur
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Slur
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StaffDivide
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StaffDivide
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StaffDivide
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StaffLayout
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StaffLayout
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StaffLayout
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Stem
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Stem
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Stem
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Stick
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Stick
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Stick
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CmpString
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CmpString
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CmpString
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FrameNote
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FrameNote
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FrameNote
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Frame
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Frame
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Frame
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StringMute
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StringMute
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StringMute
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StrongAccent
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StrongAccent
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StrongAccent
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StyleText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StyleText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StyleText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Supports
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Supports
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Supports
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SystemDividers
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SystemDividers
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SystemDividers
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Tap
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Tap
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Tap
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TextElementData
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TextElementData
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TextElementData
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Tie
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Tie
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Tie
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Tied
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Tied
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Tied
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Transpose
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Transpose
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Transpose
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Tremolo
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Tremolo
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Tremolo
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TupletDot
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TupletDot
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TupletDot
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TupletNumber
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TupletNumber
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TupletNumber
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TupletType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TupletType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TupletType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TupletPortion
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TupletPortion
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TupletPortion
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Tuplet
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Tuplet
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Tuplet
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TypedText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TypedText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TypedText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.VirtualInstrument
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.VirtualInstrument
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.VirtualInstrument
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.WavyLine
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.WavyLine
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.WavyLine
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Wedge
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Wedge
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Wedge
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Work
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Work
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Work
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxArrow
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxArrow
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxArrow
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Arrow
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Arrow
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Arrow
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxArticulations
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxArticulations
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxArticulations
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Articulations
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Articulations
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Articulations
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxBend
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxBend
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxBend
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Bend
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Bend
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Bend
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxCredit0
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxCredit0
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxCredit0
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxCredit1
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxCredit1
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxCredit1
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxDirectionType0
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxDirectionType0
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxDirectionType0
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxDynamics
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxDynamics
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxDynamics
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Dynamics
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Dynamics
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Dynamics
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxEncoding
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxEncoding
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxEncoding
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Encoding
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Encoding
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Encoding
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Identification
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Identification
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Identification
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxHarmonic
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxHarmonic
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxHarmonic
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxHarmonic1
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxHarmonic1
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxHarmonic1
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Harmonic
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Harmonic
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Harmonic
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxHarmonyChord
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxHarmonyChord
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxHarmonyChord
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxNameDisplay
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxNameDisplay
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxNameDisplay
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NameDisplay
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NameDisplay
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NameDisplay
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxNoteheadText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxNoteheadText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxNoteheadText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NoteheadText
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NoteheadText
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NoteheadText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxOrnaments
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxOrnaments
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxOrnaments
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxPercussion
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxPercussion
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxPercussion
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Percussion
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Percussion
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Percussion
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxPlay
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxPlay
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxPlay
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Play
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Play
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Play
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxScoreInstrument
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxScoreInstrument
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxScoreInstrument
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ScoreInstrument
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ScoreInstrument
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ScoreInstrument
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxTechnical
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxTechnical
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxTechnical
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Technical
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Technical
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Technical
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqCredit
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqCredit
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqCredit
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxCredit
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxCredit
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxCredit
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Credit
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Credit
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Credit
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqLyric0
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqLyric0
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqLyric0
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqLyric
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqLyric
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqLyric
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxLyric
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxLyric
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxLyric
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqMetronome
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqMetronome
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqMetronome
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqMetronomeTuplet
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqMetronomeTuplet
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqMetronomeTuplet
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqOrnaments
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqOrnaments
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqOrnaments
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Ornaments
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Ornaments
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Ornaments
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxNotations
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxNotations
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxNotations
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqPageLayout
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqPageLayout
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqPageLayout
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqScorePart
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqScorePart
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqScorePart
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CmpScorePart
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CmpScorePart
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CmpScorePart
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqSlash
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqSlash
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqSlash
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqSound
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqSound
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqSound
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Sound
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Sound
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Sound
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SeqTimeModification
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SeqTimeModification
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SeqTimeModification
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TimeModification
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TimeModification
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TimeModification
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BeatUnit
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BeatUnit
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BeatUnit
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BeatUnitTied
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BeatUnitTied
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BeatUnitTied
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxMetronome0
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxMetronome0
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxMetronome0
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxMetronome
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxMetronome
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxMetronome
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Metronome
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Metronome
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Metronome
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.DisplayStepOctave
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.DisplayStepOctave
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.DisplayStepOctave
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Unpitched
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Unpitched
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Unpitched
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Rest
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Rest
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Rest
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FullNote
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FullNote
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FullNote
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Duration
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Duration
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Duration
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Footnote
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Footnote
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Footnote
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GrpFullNote
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GrpFullNote
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GrpFullNote
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxNote0
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxNote0
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxNote0
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxNote
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxNote
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxNote
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.HarmonyChord
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.HarmonyChord
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.HarmonyChord
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LeftRightMargins
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.LeftRightMargins
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.LeftRightMargins
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.AllMargins
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.AllMargins
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.AllMargins
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PageMargins
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PageMargins
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PageMargins
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PageLayout
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PageLayout
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PageLayout
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SystemMargins
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SystemMargins
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SystemMargins
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SystemLayout
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.SystemLayout
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.SystemLayout
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Layout
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Layout
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Layout
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Print
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Print
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Print
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Defaults
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Defaults
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Defaults
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GrpLevel
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GrpLevel
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GrpLevel
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Editorial
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Editorial
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Editorial
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PartGroup
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PartGroup
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PartGroup
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Notations
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Notations
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Notations
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Lyric
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Lyric
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Lyric
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Figure
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Figure
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Figure
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.FiguredBass
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.FiguredBass
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.FiguredBass
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Barline
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Barline
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Barline
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Backup
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Backup
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Backup
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NonTraditionalKey
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.NonTraditionalKey
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.NonTraditionalKey
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GrpPartGroup
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.GrpPartGroup
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.GrpPartGroup
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ScorePart
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ScorePart
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ScorePart
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxPartList
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxPartList
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxPartList
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PartList
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.PartList
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.PartList
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ScoreHeader
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ScoreHeader
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ScoreHeader
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Slash
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Slash
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Slash
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CmpSlash
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CmpSlash
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CmpSlash
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BeatRepeat
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.BeatRepeat
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.BeatRepeat
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxMeasureStyle
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxMeasureStyle
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxMeasureStyle
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MeasureStyle
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MeasureStyle
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MeasureStyle
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Staff
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Staff
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Staff
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Harmony
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Harmony
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Harmony
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TimeSignature
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TimeSignature
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TimeSignature
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Interchangeable
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Interchangeable
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Interchangeable
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxTime
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxTime
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxTime
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Time
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Time
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Time
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TraditionalKey
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.TraditionalKey
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.TraditionalKey
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxKey
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxKey
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxKey
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Key
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Key
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Key
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Tuning
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Tuning
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Tuning
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StaffTuning
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StaffTuning
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StaffTuning
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StaffDetails
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.StaffDetails
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.StaffDetails
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Attributes
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Attributes
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Attributes
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Accord
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Accord
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Accord
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Scordatura
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Scordatura
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Scordatura
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxDirectionType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxDirectionType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxDirectionType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.DirectionType
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.DirectionType
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.DirectionType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Voice
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Voice
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Voice
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EditorialVoiceDirection
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EditorialVoiceDirection
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EditorialVoiceDirection
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Direction
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Direction
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Direction
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EditorialVoice
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.EditorialVoice
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.EditorialVoice
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Note
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Note
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Note
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Forward
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Forward
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Forward
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ChxMusicData
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ChxMusicData
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ChxMusicData
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MusicData
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.MusicData
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.MusicData
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Part
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Part
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Part
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CmpMeasure
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CmpMeasure
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CmpMeasure
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ScoreTimewise
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ScoreTimewise
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ScoreTimewise
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Measure
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.Measure
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.Measure
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CmpPart
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.CmpPart
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.CmpPart
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ScorePartwise
instance GHC.Generics.Generic Fadno.MusicXml.MusicXml31.ScorePartwise
instance GHC.Classes.Eq Fadno.MusicXml.MusicXml31.ScorePartwise
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ScorePartwise
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CmpPart
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Measure
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ScoreTimewise
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CmpMeasure
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Part
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MusicData
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxMusicData
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Forward
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Note
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EditorialVoice
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Direction
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EditorialVoiceDirection
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Voice
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.DirectionType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxDirectionType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Scordatura
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Accord
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Attributes
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StaffDetails
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StaffTuning
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Tuning
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Key
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxKey
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TraditionalKey
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Time
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxTime
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Interchangeable
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TimeSignature
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Harmony
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Staff
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MeasureStyle
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxMeasureStyle
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BeatRepeat
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CmpSlash
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Slash
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ScoreHeader
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PartList
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxPartList
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ScorePart
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GrpPartGroup
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NonTraditionalKey
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Backup
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Barline
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FiguredBass
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Figure
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Lyric
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Notations
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PartGroup
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Editorial
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GrpLevel
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Defaults
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Print
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Layout
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SystemLayout
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SystemMargins
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PageLayout
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PageMargins
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.AllMargins
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LeftRightMargins
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HarmonyChord
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxNote
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxNote0
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GrpFullNote
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Footnote
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Duration
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FullNote
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Rest
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Unpitched
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.DisplayStepOctave
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Metronome
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxMetronome
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxMetronome0
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BeatUnitTied
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BeatUnit
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TimeModification
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqTimeModification
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Sound
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqSound
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqSlash
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CmpScorePart
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqScorePart
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqPageLayout
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxNotations
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Ornaments
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqOrnaments
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqMetronomeTuplet
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqMetronome
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxLyric
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqLyric
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqLyric0
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Credit
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxCredit
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SeqCredit
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Technical
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxTechnical
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ScoreInstrument
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxScoreInstrument
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Play
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxPlay
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Percussion
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxPercussion
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxOrnaments
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NoteheadText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxNoteheadText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NameDisplay
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxNameDisplay
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxHarmonyChord
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Harmonic
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxHarmonic1
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxHarmonic
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Identification
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Encoding
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxEncoding
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Dynamics
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxDynamics
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxDirectionType0
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxCredit1
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxCredit0
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Bend
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxBend
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Articulations
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxArticulations
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Arrow
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ChxArrow
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Work
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Wedge
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.WavyLine
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.VirtualInstrument
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TypedText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Tuplet
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TupletPortion
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TupletType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TupletNumber
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TupletDot
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Tremolo
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Transpose
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Tied
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Tie
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TextElementData
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Tap
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SystemDividers
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Supports
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StyleText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StrongAccent
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StringMute
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Frame
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FrameNote
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CmpString
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Stick
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Stem
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StaffLayout
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StaffDivide
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Slur
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Slide
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Segno
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Scaling
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Root
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.RootStep
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.RootAlter
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Repeat
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PrincipalVoice
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PlacementText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Pitched
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Pitch
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PerMinute
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HarpPedals
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PedalTuning
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Pedal
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PartSymbol
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PartName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OtherText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OtherPlay
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OtherPlacementText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OtherNotation
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OtherDirection
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Appearance
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OtherAppearance
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Opus
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Offset
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OctaveShift
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Notehead
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NoteType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NoteSize
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NonArpeggiate
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MultipleRest
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Mordent
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Miscellaneous
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MiscellaneousField
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MidiInstrument
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MidiDevice
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MetronomeNote
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MetronomeTuplet
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MetronomeTied
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MetronomeBeam
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MeasureRepeat
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MeasureNumbering
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MeasureLayout
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LyricLanguage
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LyricFont
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Link
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LineWidth
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Level
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Kind
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.KeyOctave
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.KeyAccidental
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Inversion
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Instrument
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Image
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HorizontalTurn
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Hole
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HoleClosed
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HeelToe
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HarmonMute
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HarmonClosed
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Handbell
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HammerOnPullOff
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Grouping
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GroupSymbol
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GroupName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GroupBarline
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Grace
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Glyph
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Glissando
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Glass
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Fret
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FormattedTextId
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FormattedText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FormattedSymbolId
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FirstFret
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Fingering
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Fermata
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Feature
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Extend
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Ending
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EmptyTrillSound
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EmptyPrintStyleAlignId
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EmptyPrintObjectStyleAlign
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EmptyPlacementSmufl
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EmptyPlacement
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EmptyLine
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EmptyFont
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.AccordionRegistration
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Empty
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Elision
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Distance
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Directive
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Degree
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.DegreeValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.DegreeType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.DegreeAlter
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Dashes
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Coda
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Clef
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Cancel
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Caesura
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BreathMark
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Bracket
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Bookmark
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Beater
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Beam
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Bass
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BassStep
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BassAlter
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Barre
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BarStyleColor
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Arpeggiate
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.AccidentalText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.AccidentalMark
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Accidental
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PositiveIntegerOrEmpty
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SumPositiveIntegerOrEmpty
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NumberOrNormal
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SumNumberOrNormal
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Lang
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SumLang
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.YyyyMmDd
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.YyyyMmDd
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.YyyyMmDd
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.YesNoNumber
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.YesNo
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Wood
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Winged
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.WedgeType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ValignImage
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Valign
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.UprightInverted
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.UpDownStopContinue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.UpDown
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Type
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TwoNoteTurn
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TrillStep
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TrillBeats
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.TrillBeats
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TrillBeats
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TremoloType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TremoloMarks
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.TremoloMarks
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TremoloMarks
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TopBottom
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SmuflAccidentalGlyphName
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.SmuflAccidentalGlyphName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SmuflAccidentalGlyphName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SmuflCodaGlyphName
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.SmuflCodaGlyphName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SmuflCodaGlyphName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SmuflLyricsGlyphName
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.SmuflLyricsGlyphName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SmuflLyricsGlyphName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SmuflPictogramGlyphName
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.SmuflPictogramGlyphName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SmuflPictogramGlyphName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SmuflSegnoGlyphName
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.SmuflSegnoGlyphName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SmuflSegnoGlyphName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.SmuflGlyphName
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.SmuflGlyphName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SmuflGlyphName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NMTOKEN
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.NMTOKEN
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NMTOKEN
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.ID
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.ID
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ID
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.IDREF
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.IDREF
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.IDREF
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NCName
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.NCName
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NCName
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Name
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Name
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Name
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Color
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Color
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Color
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.CommaSeparatedText
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.CommaSeparatedText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CommaSeparatedText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.DistanceType
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.DistanceType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.DistanceType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.EndingNumber
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.EndingNumber
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EndingNumber
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.GlyphType
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.GlyphType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GlyphType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Language
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Language
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Language
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.LineWidthType
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.LineWidthType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LineWidthType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.MeasureText
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.MeasureText
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MeasureText
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.TimeOnly
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.TimeOnly
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TimeOnly
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Token
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Token
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Token
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TipDirection
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TimeSymbol
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TimeSeparator
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TimeRelation
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TiedType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TextDirection
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Tenths
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Tenths
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Tenths
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.TapHand
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SymbolSize
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Syllabic
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StringNumber
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.StringNumber
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StringNumber
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StickType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StickMaterial
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StickLocation
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Step
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StemValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StartStopSingle
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StartStopDiscontinue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StartStopContinue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StartStop
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StartNote
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StaffType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.StaffNumber
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StaffNumber
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.StaffLine
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.StaffLine
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StaffLine
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.StaffDivideSymbol
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Space
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ShowTuplet
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ShowFrets
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SmpShow
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Semitones
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Semitones
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Semitones
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.SemiPitched
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.RotationDegrees
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.RotationDegrees
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.RotationDegrees
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.RightLeftMiddle
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PrincipalVoiceSymbol
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.AccordionMiddle
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.AccordionMiddle
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.BeamLevel
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BeamLevel
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Midi128
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Midi128
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Midi16
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Midi16
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Midi16384
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Midi16384
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.NumberLevel
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NumberLevel
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.PositiveInteger
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PositiveInteger
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.PositiveDivisions
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.PositiveDivisions
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PositiveDivisions
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PitchedValue
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Percent
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Percent
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Percent
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.PedalType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OverUnder
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.OnOff
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Octave
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Octave
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Octave
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NumberOfLines
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.NumberOfLines
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NumberOfLines
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NoteheadValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NoteTypeValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NoteSizeType
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NormalizedString
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.NormalizedString
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NormalizedString
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NonNegativeInteger
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.NonNegativeDecimal
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Mute
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Mode
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Mode
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Mode
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Millimeters
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Millimeters
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Millimeters
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Metal
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Membrane
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MeasureNumberingValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.MarginType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LineType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LineShape
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LineLength
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LineEnd
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LeftRight
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.LeftCenterRight
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.KindValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HoleClosedValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HoleClosedLocation
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HarmonyType
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HarmonClosedValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HarmonClosedLocation
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.HandbellValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GroupSymbolValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GroupBarlineValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.GlassValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FontWeight
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FontStyle
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FontSize
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Fifths
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Fifths
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Fifths
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.FermataShape
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Fan
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.EnclosureShape
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Effect
instance GHC.Show.Show Fadno.MusicXml.MusicXml31.Divisions
instance GHC.Read.Read Fadno.MusicXml.MusicXml31.Divisions
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Divisions
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.DegreeTypeValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.DegreeSymbolValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CssFontSize
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ClefSign
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CircularArrow
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CancelLocation
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.CaesuraValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BreathMarkValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BeaterValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BeamValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BarStyle
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.BackwardForward
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ArrowStyle
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.ArrowDirection
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.Actuate
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.AccidentalValue
instance Fadno.Xml.EmitXml.EmitXml Fadno.MusicXml.MusicXml31.AboveBelow


-- | Backtracking combinators for consuming XML productions (elements,
--   attributes).

-- | <i>Deprecated: in favor of XParse</i>
module Fadno.Xml.XParser

-- | Stack entry tracking identified elements.
--   
--   XParser constraint kind. Stack state + alternative + errors.
type XParser m = (Alternative m, MonadState [Element] m, MonadError String m)

-- | run XParser on an element.
parseX :: Monad m => StateT [Element] (ExceptT String m) b -> Element -> m (Either String b)

-- | Stack peek.
peek :: XParser m => m Element

-- | Stack push.
push :: XParser m => Element -> m ()

-- | Stack pop.
pop :: XParser m => m ()

-- | Verify populated stack.
checkStack :: XParser m => m [Element]

-- | Verify and "consume" current element.
atEl :: XParser m => QName -> m ()

-- | Find child element and act on it.
findChild :: XParser m => QName -> m a -> m a

-- | Find zero or many children and act on them.
findChildren :: XParser m => QName -> m a -> m [a]

-- | Run optional action on all children.
anyChildren :: XParser m => m a -> m [a]

-- | Expect to find one child only, and run action on it.
oneChild :: XParser m => m a -> m a

-- | Act on all children.
allChildren :: XParser m => m a -> m [a]

-- | Flailing attempt to restore "order" by faking a single-child element
--   one at a time.
manyOrdered :: XParser m => m a -> m [a]

-- | Expect/consume a particular attribute.
attr :: XParser m => QName -> m String

-- | Get text content, returning empty string if none, per
--   <tt>strContent</tt>.
textContent :: XParser m => m String

-- | Local-only QName.
name :: String -> QName

-- | Special support for XSD QNames.
xsName :: String -> QName

-- | Convenience to read in top element from file.
readXml :: FilePath -> IO Element


-- | Parse an XSD into types with the ability to resolve references.
module Fadno.Xml.ParseXsd

-- | Parse an XSD file.
parseFile :: FilePath -> IO Schema

-- | Load XSD itself as a <a>Schema</a>.
loadXsdSchema :: FilePath -> IO Schema

-- | Main parser.
schemaParser :: XParser m => m Schema

-- | Adjust top-level names to have supplied prefix.
namespaceSchema :: String -> Schema -> Schema

-- | QName parser.
qnParser :: Parsec String m QN

-- | Attribute text parser, without whitespace.
attrParser :: Parsec String m String

-- | Run parsec.
parsec :: Stream s Identity t => Parsec s () a -> s -> a

-- | Parse a QName.
qn :: String -> QN

-- | XML Schema "anySimpleType" (ie, built-ins like string, double etc).
anySimpleTypeName :: QN

-- | Resolvable indicates a type has a <a>Ref</a> member that it can
--   resolve from a top-level <a>Schema</a> production.
class (Typeable a) => Resolvable a
resolve :: Resolvable a => Schema -> a -> a

-- | Resolve a <a>Ref</a> against a <a>Schema</a>.
refResolve :: Resolvable r => String -> Getting (Map QN r) Schema (Map QN r) -> Schema -> Ref r -> Ref r

-- | Model an outward XSD reference.
data Ref a

-- | Just type name.
Unresolved :: !QN -> Ref a
[_unresolved] :: Ref a -> !QN

-- | Type name and resolved value.
Resolved :: !QN -> !a -> Ref a
[_resolved] :: Ref a -> !QN
[_refvalue] :: Ref a -> !a

-- | Reserved for built-in types (string, etc)
Final :: Ref a
unresolved :: forall a_a2hew. Traversal' (Ref a_a2hew) QN
resolved :: forall a_a2hew. Traversal' (Ref a_a2hew) QN
refvalue :: forall a_a2hew a_a2kXZ. Traversal (Ref a_a2hew) (Ref a_a2kXZ) a_a2hew a_a2kXZ

-- | Schema type, mapping top-level productions to qnames.
data Schema
Schema :: !Map QN SimpleType -> !Map QN ComplexType -> !Map QN Group -> !Map QN AttributeGroup -> !Map QN Element -> !Map QN Attribute -> Schema
[_simpleTypes] :: Schema -> !Map QN SimpleType
[_complexTypes] :: Schema -> !Map QN ComplexType
[_groups] :: Schema -> !Map QN Group
[_attributeGroups] :: Schema -> !Map QN AttributeGroup
[_elements] :: Schema -> !Map QN Element
[_attributes] :: Schema -> !Map QN Attribute
simpleTypes :: Lens' Schema (Map QN SimpleType)
complexTypes :: Lens' Schema (Map QN ComplexType)
groups :: Lens' Schema (Map QN Group)
attributeGroups :: Lens' Schema (Map QN AttributeGroup)
elements :: Lens' Schema (Map QN Element)
attributes :: Lens' Schema (Map QN Attribute)

-- | QName type.
data QN
QN :: String -> Maybe String -> QN
[_qLocal] :: QN -> String
[_qPrefix] :: QN -> Maybe String
qLocal :: Lens' QN String
qPrefix :: Lens' QN (Maybe String)

-- | XSD simpleType production.
data SimpleType
SimpleTypeRestrict :: !Maybe QN -> !SimpleRestriction -> Maybe Documentation -> SimpleType
[_simpleTypeName] :: SimpleType -> !Maybe QN
[_simpleTypeRestriction] :: SimpleType -> !SimpleRestriction
[_simpleTypeDoc] :: SimpleType -> Maybe Documentation
SimpleTypeUnion :: !Maybe QN -> !Union -> Maybe Documentation -> SimpleType
[_simpleTypeName] :: SimpleType -> !Maybe QN
[_simpleTypeUnion] :: SimpleType -> !Union
[_simpleTypeDoc] :: SimpleType -> Maybe Documentation
simpleTypeName :: Lens' SimpleType (Maybe QN)
simpleTypeRestriction :: Traversal' SimpleType SimpleRestriction
simpleTypeUnion :: Traversal' SimpleType Union
simpleTypeDoc :: Lens' SimpleType (Maybe Documentation)

-- | Model min/max restrictions.
data Bound a
Inclusive :: a -> Bound a
Exclusive :: a -> Bound a

-- | simple type restriction production.
data SimpleRestriction
SimpleRestriction :: !Ref SimpleType -> ![String] -> !Maybe (Bound String) -> !Maybe (Bound String) -> !Maybe String -> SimpleRestriction
[_simpleRestrictBase] :: SimpleRestriction -> !Ref SimpleType
[_simpleRestrictEnums] :: SimpleRestriction -> ![String]
[_simpleRestrictMin] :: SimpleRestriction -> !Maybe (Bound String)
[_simpleRestrictMax] :: SimpleRestriction -> !Maybe (Bound String)
[_simpleRestrictPattern] :: SimpleRestriction -> !Maybe String
simpleRestrictBase :: Lens' SimpleRestriction (Ref SimpleType)
simpleRestrictEnums :: Lens' SimpleRestriction [String]
simpleRestrictMin :: Lens' SimpleRestriction (Maybe (Bound String))
simpleRestrictMax :: Lens' SimpleRestriction (Maybe (Bound String))
simpleRestrictPattern :: Lens' SimpleRestriction (Maybe String)

-- | Simple type union production.
data Union
Union :: ![Ref SimpleType] -> ![SimpleType] -> Union
[_unionMemberTypes] :: Union -> ![Ref SimpleType]
[_unionSimpleTypes] :: Union -> ![SimpleType]
unionMemberTypes :: Lens' Union [Ref SimpleType]
unionSimpleTypes :: Lens' Union [SimpleType]

-- | XSD attribute production.
data Attribute
AttributeType :: !QN -> !Ref SimpleType -> !Use -> !Maybe String -> Attribute
[_attrName] :: Attribute -> !QN
[_attrType] :: Attribute -> !Ref SimpleType
[_attrUse] :: Attribute -> !Use
[_attrDefault] :: Attribute -> !Maybe String
AttributeRef :: !Ref Attribute -> !Use -> !Maybe String -> Attribute
[_attrRef] :: Attribute -> !Ref Attribute
[_attrUse] :: Attribute -> !Use
[_attrDefault] :: Attribute -> !Maybe String
AttributeSimpleType :: !QN -> SimpleType -> Attribute
[_attrName] :: Attribute -> !QN
[_attrSimpleType] :: Attribute -> SimpleType
attrName :: Traversal' Attribute QN
attrType :: Traversal' Attribute (Ref SimpleType)
attrUse :: Traversal' Attribute Use
attrDefault :: Traversal' Attribute (Maybe String)
attrRef :: Traversal' Attribute (Ref Attribute)
attrSimpleType :: Traversal' Attribute SimpleType

-- | XSD "use" values.
data Use
Required :: Use
Optional :: Use
Prohibited :: Use

-- | XSD attribute-group production.
data AttributeGroup
AttributeGroup :: !QN -> !Attributes -> Maybe Documentation -> AttributeGroup
[_attrGroupName] :: AttributeGroup -> !QN
[_attrGroupAttributes] :: AttributeGroup -> !Attributes
[_attrGroupDoc] :: AttributeGroup -> Maybe Documentation
AttributeGroupRef :: !Ref AttributeGroup -> AttributeGroup
[_attrGroupRef] :: AttributeGroup -> !Ref AttributeGroup
attrGroupName :: Traversal' AttributeGroup QN
attrGroupAttributes :: Traversal' AttributeGroup Attributes
attrGroupRef :: Traversal' AttributeGroup (Ref AttributeGroup)
attrGroupDoc :: Traversal' AttributeGroup (Maybe Documentation)

-- | Convenience grouping of attributes and attribute groups, which are
--   always showing up together in xsd.
data Attributes
Attributes :: ![Attribute] -> ![AttributeGroup] -> Attributes
[_attrsAttributes] :: Attributes -> ![Attribute]
[_attrsAttributeGroups] :: Attributes -> ![AttributeGroup]
attrsAttributes :: Lens' Attributes [Attribute]
attrsAttributeGroups :: Lens' Attributes [AttributeGroup]

-- | "occurs-min" and "occurs-max"
data Occurs
Occurs :: !Maybe String -> !Maybe String -> Occurs
[_occursMin] :: Occurs -> !Maybe String
[_occursMax] :: Occurs -> !Maybe String
occursMin :: Lens' Occurs (Maybe String)
occursMax :: Lens' Occurs (Maybe String)

-- | XSD element production.
data Element
ElementType :: !QN -> !Ref (Either ComplexType SimpleType) -> !Occurs -> Maybe Documentation -> Element
[_elementName] :: Element -> !QN
[_elementType] :: Element -> !Ref (Either ComplexType SimpleType)
[_elementOccurs] :: Element -> !Occurs
[_elementDoc] :: Element -> Maybe Documentation
ElementSimple :: !QN -> !SimpleType -> !Occurs -> Maybe Documentation -> Element
[_elementName] :: Element -> !QN
[_elementSimple] :: Element -> !SimpleType
[_elementOccurs] :: Element -> !Occurs
[_elementDoc] :: Element -> Maybe Documentation
ElementComplex :: !QN -> !ComplexType -> !Occurs -> Maybe Documentation -> Element
[_elementName] :: Element -> !QN
[_elementComplex] :: Element -> !ComplexType
[_elementOccurs] :: Element -> !Occurs
[_elementDoc] :: Element -> Maybe Documentation
ElementRef :: !Ref Element -> !Occurs -> Element
[_elementRef] :: Element -> !Ref Element
[_elementOccurs] :: Element -> !Occurs
elementName :: Traversal' Element QN
elementType :: Traversal' Element (Ref (Either ComplexType SimpleType))
elementOccurs :: Lens' Element Occurs
elementSimple :: Traversal' Element SimpleType
elementComplex :: Traversal' Element ComplexType
elementRef :: Traversal' Element (Ref Element)
elementDoc :: Traversal' Element (Maybe Documentation)

-- | XSD complexType production.
data ComplexType
ComplexTypeSimple :: !Maybe QN -> !SimpleContent -> Maybe Documentation -> ComplexType
[_complexTypeName] :: ComplexType -> !Maybe QN
[_complexSimpleContent] :: ComplexType -> !SimpleContent
[_complexTypeDoc] :: ComplexType -> Maybe Documentation
ComplexTypeComplex :: !Maybe QN -> !ComplexContent -> Maybe Documentation -> ComplexType
[_complexTypeName] :: ComplexType -> !Maybe QN
[_complexComplexContent] :: ComplexType -> !ComplexContent
[_complexTypeDoc] :: ComplexType -> Maybe Documentation
ComplexTypeCompositor :: !Maybe QN -> !Maybe Compositor -> !Attributes -> Maybe Documentation -> ComplexType
[_complexTypeName] :: ComplexType -> !Maybe QN
[_complexCompositor] :: ComplexType -> !Maybe Compositor
[_complexAttributes] :: ComplexType -> !Attributes
[_complexTypeDoc] :: ComplexType -> Maybe Documentation
complexTypeName :: Lens' ComplexType (Maybe QN)
complexSimpleContent :: Traversal' ComplexType SimpleContent
complexComplexContent :: Traversal' ComplexType ComplexContent
complexCompositor :: Traversal' ComplexType (Maybe Compositor)
complexAttributes :: Traversal' ComplexType Attributes
complexTypeDoc :: Lens' ComplexType (Maybe Documentation)

-- | simpleContent under a complex type.
data SimpleContent
SimpleContentExtension :: !Ref SimpleType -> !Attributes -> SimpleContent
[_simpleContentBase] :: SimpleContent -> !Ref SimpleType
[_simpleContentAttributes] :: SimpleContent -> !Attributes
simpleContentBase :: Lens' SimpleContent (Ref SimpleType)
simpleContentAttributes :: Lens' SimpleContent Attributes

-- | complexContent under a complex type. TODO: restrictions
data ComplexContent
ComplexContentExtension :: !Ref ComplexType -> !Attributes -> Maybe Compositor -> ComplexContent
[_complexContentBase] :: ComplexContent -> !Ref ComplexType
[_complexContentAttributes] :: ComplexContent -> !Attributes
[_complexContentCompositor] :: ComplexContent -> Maybe Compositor
complexContentBase :: Lens' ComplexContent (Ref ComplexType)
complexContentAttributes :: Lens' ComplexContent Attributes
complexContentCompositor :: Lens' ComplexContent (Maybe Compositor)

-- | Compositors.
data Compositor
CompositorGroup :: !Group -> Compositor
[_compGroup] :: Compositor -> !Group
CompositorChoice :: !Choice -> Compositor
[_compChoice] :: Compositor -> !Choice
CompositorSequence :: !Sequence -> Compositor
[_compSequence] :: Compositor -> !Sequence
compGroup :: Traversal' Compositor Group
compChoice :: Traversal' Compositor Choice
compSequence :: Traversal' Compositor Sequence

-- | XSD "group" production.
data Group
GroupChoice :: !Maybe QN -> !Occurs -> !Choice -> Maybe Documentation -> Group
[_groupName] :: Group -> !Maybe QN
[_groupOccurs] :: Group -> !Occurs
[_groupChoice] :: Group -> !Choice
[_groupDoc] :: Group -> Maybe Documentation
GroupSequence :: !Maybe QN -> !Occurs -> !Sequence -> Maybe Documentation -> Group
[_groupName] :: Group -> !Maybe QN
[_groupOccurs] :: Group -> !Occurs
[_groupSequence] :: Group -> !Sequence
[_groupDoc] :: Group -> Maybe Documentation
GroupRef :: !Ref Group -> !Occurs -> Group
[_groupRef] :: Group -> !Ref Group
[_groupOccurs] :: Group -> !Occurs
groupName :: Traversal' Group (Maybe QN)
groupOccurs :: Lens' Group Occurs
groupChoice :: Traversal' Group Choice
groupSequence :: Traversal' Group Sequence
groupRef :: Traversal' Group (Ref Group)
groupDoc :: Traversal' Group (Maybe Documentation)

-- | Particles.
data Particle
PartElement :: !Element -> Particle
[_partElement] :: Particle -> !Element
PartGroup :: !Group -> Particle
[_partGroup] :: Particle -> !Group
PartChoice :: !Choice -> Particle
[_partChoice] :: Particle -> !Choice
PartSequence :: !Sequence -> Particle
[_partSequence] :: Particle -> !Sequence
partElement :: Traversal' Particle Element
partGroup :: Traversal' Particle Group
partChoice :: Traversal' Particle Choice
partSequence :: Traversal' Particle Sequence

-- | XSD choice
data Choice
Choice :: !Occurs -> ![Particle] -> Choice
[_choiceOccurs] :: Choice -> !Occurs
[_choiceParticles] :: Choice -> ![Particle]
choiceOccurs :: Lens' Choice Occurs
choiceParticles :: Lens' Choice [Particle]

-- | XSD sequence.
data Sequence
Sequence :: !Occurs -> ![Particle] -> Sequence
[_sequenceOccurs] :: Sequence -> !Occurs
[_sequenceParticles] :: Sequence -> ![Particle]
sequenceOccurs :: Lens' Sequence Occurs
sequenceParticles :: Lens' Sequence [Particle]
newtype Documentation
Documentation :: String -> Documentation
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.AttributeGroup
instance Fadno.Xml.ParseXsd.Resolvable (Fadno.Xml.ParseXsd.Ref Fadno.Xml.ParseXsd.AttributeGroup)
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.Group
instance Fadno.Xml.ParseXsd.Resolvable (Fadno.Xml.ParseXsd.Ref Fadno.Xml.ParseXsd.Group)
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.ComplexContent
instance Fadno.Xml.ParseXsd.Resolvable (Fadno.Xml.ParseXsd.Ref Fadno.Xml.ParseXsd.ComplexType)
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.SimpleContent
instance Fadno.Xml.ParseXsd.Resolvable (Fadno.Xml.ParseXsd.Ref Fadno.Xml.ParseXsd.SimpleType)
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.Element
instance Fadno.Xml.ParseXsd.Resolvable (Fadno.Xml.ParseXsd.Ref (Data.Either.Either Fadno.Xml.ParseXsd.ComplexType Fadno.Xml.ParseXsd.SimpleType))
instance Fadno.Xml.ParseXsd.Resolvable (Fadno.Xml.ParseXsd.Ref Fadno.Xml.ParseXsd.Element)
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.ComplexType
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.SimpleType
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.SimpleRestriction
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.Union
instance Fadno.Xml.ParseXsd.Resolvable Fadno.Xml.ParseXsd.Attribute
instance Fadno.Xml.ParseXsd.Resolvable (Fadno.Xml.ParseXsd.Ref Fadno.Xml.ParseXsd.Attribute)
instance GHC.Classes.Ord Fadno.Xml.ParseXsd.QN
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.QN
instance Data.Data.Data Fadno.Xml.ParseXsd.QN
instance GHC.Classes.Eq a => GHC.Classes.Eq (Fadno.Xml.ParseXsd.Ref a)
instance Data.Data.Data a => Data.Data.Data (Fadno.Xml.ParseXsd.Ref a)
instance Data.Data.Data Fadno.Xml.ParseXsd.Documentation
instance GHC.Classes.Ord Fadno.Xml.ParseXsd.Documentation
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Documentation
instance GHC.Classes.Ord a => GHC.Classes.Ord (Fadno.Xml.ParseXsd.Bound a)
instance GHC.Base.Functor Fadno.Xml.ParseXsd.Bound
instance GHC.Show.Show a => GHC.Show.Show (Fadno.Xml.ParseXsd.Bound a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Fadno.Xml.ParseXsd.Bound a)
instance Data.Data.Data a => Data.Data.Data (Fadno.Xml.ParseXsd.Bound a)
instance GHC.Show.Show Fadno.Xml.ParseXsd.SimpleRestriction
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.SimpleRestriction
instance Data.Data.Data Fadno.Xml.ParseXsd.SimpleRestriction
instance GHC.Show.Show Fadno.Xml.ParseXsd.SimpleType
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.SimpleType
instance Data.Data.Data Fadno.Xml.ParseXsd.SimpleType
instance GHC.Show.Show Fadno.Xml.ParseXsd.Union
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Union
instance Data.Data.Data Fadno.Xml.ParseXsd.Union
instance GHC.Show.Show Fadno.Xml.ParseXsd.Use
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Use
instance Data.Data.Data Fadno.Xml.ParseXsd.Use
instance GHC.Show.Show Fadno.Xml.ParseXsd.Attribute
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Attribute
instance Data.Data.Data Fadno.Xml.ParseXsd.Attribute
instance GHC.Show.Show Fadno.Xml.ParseXsd.AttributeGroup
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.AttributeGroup
instance Data.Data.Data Fadno.Xml.ParseXsd.AttributeGroup
instance GHC.Show.Show Fadno.Xml.ParseXsd.Attributes
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Attributes
instance Data.Data.Data Fadno.Xml.ParseXsd.Attributes
instance GHC.Show.Show Fadno.Xml.ParseXsd.Occurs
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Occurs
instance Data.Data.Data Fadno.Xml.ParseXsd.Occurs
instance GHC.Show.Show Fadno.Xml.ParseXsd.SimpleContent
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.SimpleContent
instance Data.Data.Data Fadno.Xml.ParseXsd.SimpleContent
instance GHC.Show.Show Fadno.Xml.ParseXsd.ComplexContent
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.ComplexContent
instance Data.Data.Data Fadno.Xml.ParseXsd.ComplexContent
instance GHC.Show.Show Fadno.Xml.ParseXsd.Compositor
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Compositor
instance Data.Data.Data Fadno.Xml.ParseXsd.Compositor
instance GHC.Show.Show Fadno.Xml.ParseXsd.ComplexType
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.ComplexType
instance Data.Data.Data Fadno.Xml.ParseXsd.ComplexType
instance GHC.Show.Show Fadno.Xml.ParseXsd.Element
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Element
instance Data.Data.Data Fadno.Xml.ParseXsd.Element
instance GHC.Show.Show Fadno.Xml.ParseXsd.Group
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Group
instance Data.Data.Data Fadno.Xml.ParseXsd.Group
instance GHC.Show.Show Fadno.Xml.ParseXsd.Choice
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Choice
instance Data.Data.Data Fadno.Xml.ParseXsd.Choice
instance GHC.Show.Show Fadno.Xml.ParseXsd.Particle
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Particle
instance Data.Data.Data Fadno.Xml.ParseXsd.Particle
instance GHC.Show.Show Fadno.Xml.ParseXsd.Sequence
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Sequence
instance Data.Data.Data Fadno.Xml.ParseXsd.Sequence
instance GHC.Classes.Eq Fadno.Xml.ParseXsd.Schema
instance Data.Data.Data Fadno.Xml.ParseXsd.Schema
instance GHC.Show.Show Fadno.Xml.ParseXsd.Schema
instance GHC.Base.Semigroup Fadno.Xml.ParseXsd.Schema
instance GHC.Base.Monoid Fadno.Xml.ParseXsd.Schema
instance GHC.Show.Show Fadno.Xml.ParseXsd.Documentation
instance GHC.Show.Show (Fadno.Xml.ParseXsd.Ref a)
instance GHC.Show.Show Fadno.Xml.ParseXsd.QN


-- | Consume a <a>Schema</a> and emit types intended for code generation.
module Fadno.Xml.EmitTypes

-- | Emit schema types. Starts with element productions and emits all
--   dependent types.
emitSchema :: Schema -> Emit ()

-- | Emit type for element content; element name production captured in
--   containing field.
emitElement :: Element -> Emit Type

-- | Handle simpleType production.
emitSimpleType :: SimpleType -> Emit Type

-- | Complex type. <tt>anon</tt> arg indicates element-defined complex
--   type, therefore unique; otherwise defined type.
emitComplexType :: Maybe QN -> ComplexType -> Emit Type

-- | Emit compositor field.
emitCompositor :: [QN] -> Compositor -> Emit [Field]

-- | Emit group. Referenced groups make types, others pass through.
emitGroup :: [QN] -> Group -> Emit [Field]

-- | Choice production.
emitChoice :: [QN] -> Choice -> Maybe Documentation -> Emit [Field]

-- | Sequence production.
emitSequence :: [QN] -> Maybe Occurs -> Sequence -> Maybe Documentation -> Emit [Field]

-- | Particle field production. Element fields emit containing element.
emitParticle :: [QN] -> Particle -> Emit [Field]

-- | Handle attribute and attribute group productions as fields.
emitAttrFields :: Attributes -> Emit [Field]

-- | Emit monad.
type Emit a = ReaderT Env (StateT EmitState IO) a

-- | Reader environment.
data Env
Env :: Schema -> Env
[_schema] :: Env -> Schema
schema :: Iso' Env Schema

-- | State data.
data EmitState
EmitState :: Map Name Type -> [Name] -> EmitState
[_types] :: EmitState -> Map Name Type
[_stack] :: EmitState -> [Name]
types :: Lens' EmitState (Map Name Type)
stack :: Lens' EmitState [Name]

-- | Run emit monad.
runEmit :: Env -> EmitState -> Emit a -> IO (a, EmitState)

-- | Error out in IO.
die :: MonadIO m => String -> m a

-- | Type name.
data Name
Name :: Namespace -> QN -> Int -> Name
[nNamespace] :: Name -> Namespace
[nName] :: Name -> QN
[nIdx] :: Name -> Int

-- | Namespaces for various productions.
data Namespace
NSElement :: Namespace
NSSimple :: Namespace
NSUnion :: Namespace
NSComplex :: Namespace
NSBuiltIn :: Namespace
NSChoice :: Namespace
NSSequence :: Namespace
NSGroup :: Namespace

-- | Field cardinality
data Cardinality
One :: Cardinality
ZeroOrOne :: Cardinality
Many :: Cardinality

-- | Type field.
data Field
Field :: QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
[_fieldName] :: Field -> QN
[_fieldType] :: Field -> Type
[_fieldCardinality] :: Field -> Cardinality
[_fieldXmlEmit] :: Field -> FieldEmit
[_fieldIdx] :: Field -> Int
fieldName :: Lens' Field QN
fieldType :: Lens' Field Type
fieldCardinality :: Lens' Field Cardinality
fieldXmlEmit :: Lens' Field FieldEmit
fieldIdx :: Lens' Field Int

-- | Field xml emit cue.
data FieldEmit
FieldAttribute :: FieldEmit
FieldElement :: FieldEmit
FieldText :: FieldEmit
FieldOther :: FieldEmit

-- | Datatype constructor.
data Ctor
Ctor :: String -> [Field] -> Ctor
[_ctorName] :: Ctor -> String
[_ctorFields] :: Ctor -> [Field]
ctorName :: Lens' Ctor String
ctorFields :: Lens' Ctor [Field]

-- | Emitted type.
data Type
NewType :: Name -> Type -> DerivesFamily -> [Impl] -> Maybe Documentation -> Type
[_typeName] :: Type -> Name
[_typeType] :: Type -> Type
[_typeDerives] :: Type -> DerivesFamily
[_typeImpls] :: Type -> [Impl]
[_typeDoc] :: Type -> Maybe Documentation
DataType :: Name -> [Ctor] -> DerivesFamily -> [Impl] -> DataTypeEmit -> Maybe Documentation -> Type
[_typeName] :: Type -> Name
[_typeCtors] :: Type -> [Ctor]
[_typeDerives] :: Type -> DerivesFamily
[_typeImpls] :: Type -> [Impl]
[_typeEmit] :: Type -> DataTypeEmit
[_typeDoc] :: Type -> Maybe Documentation
EnumType :: Name -> [String] -> DerivesFamily -> [Impl] -> Maybe Documentation -> Type
[_typeName] :: Type -> Name
[_typeEnumValues] :: Type -> [String]
[_typeDerives] :: Type -> DerivesFamily
[_typeImpls] :: Type -> [Impl]
[_typeDoc] :: Type -> Maybe Documentation
BuiltIn :: Name -> CoreType -> DerivesFamily -> [Impl] -> Type
[_typeName] :: Type -> Name
[_coreType] :: Type -> CoreType
[_typeDerives] :: Type -> DerivesFamily
[_typeImpls] :: Type -> [Impl]
typeName :: Lens' Type Name
typeType :: Traversal' Type Type
typeDerives :: Lens' Type DerivesFamily
typeImpls :: Lens' Type [Impl]
typeEmit :: Traversal' Type DataTypeEmit
typeCtors :: Traversal' Type [Ctor]
typeEnumValues :: Traversal' Type [String]
coreType :: Traversal' Type CoreType

-- | Derive type "families".
data DerivesFamily
NewTypeString :: DerivesFamily
NewTypeIntegral :: DerivesFamily
NewTypeNum :: DerivesFamily
DataEnum :: DerivesFamily
OtherDerives :: DerivesFamily

-- | Data type xml emit cue.
data DataTypeEmit
DataTypeComplex :: DataTypeEmit
DataTypeSimple :: DataTypeEmit
DataTypeCompositor :: DataTypeEmit

-- | newtype base types. Name after CT should be Haskell base type.
data CoreType
CTString :: CoreType
CTDecimal :: CoreType
CTFloat :: CoreType
CTDouble :: CoreType
CTInt :: CoreType
CTBool :: CoreType

-- | <a>Impl</a>s of classes, but also grab-bag of type deets.
data Impl

-- | Specifies min and max values
Bounds :: (Maybe (Bound String), Maybe (Bound String)) -> Impl

-- | Specifies string pattern
Pattern :: String -> Impl

-- | Implement <a>Show</a> for newtype
NewTypeShow :: Impl

-- | Top-level element, so emit element name as well as contents. Elements
--   normally inherit the name from the referencing production.
TopLevel :: Impl
instance GHC.Base.Semigroup Fadno.Xml.EmitTypes.EmitState
instance GHC.Base.Monoid Fadno.Xml.EmitTypes.EmitState
instance GHC.Enum.Bounded Fadno.Xml.EmitTypes.Cardinality
instance GHC.Enum.Enum Fadno.Xml.EmitTypes.Cardinality
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.Cardinality
instance Data.Data.Data Fadno.Xml.EmitTypes.Cardinality
instance GHC.Show.Show Fadno.Xml.EmitTypes.Cardinality
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.Cardinality
instance GHC.Enum.Bounded Fadno.Xml.EmitTypes.Namespace
instance GHC.Enum.Enum Fadno.Xml.EmitTypes.Namespace
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.Namespace
instance Data.Data.Data Fadno.Xml.EmitTypes.Namespace
instance GHC.Show.Show Fadno.Xml.EmitTypes.Namespace
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.Namespace
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.Name
instance Data.Data.Data Fadno.Xml.EmitTypes.Name
instance GHC.Show.Show Fadno.Xml.EmitTypes.Name
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.Name
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.FieldEmit
instance Data.Data.Data Fadno.Xml.EmitTypes.FieldEmit
instance GHC.Show.Show Fadno.Xml.EmitTypes.FieldEmit
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.FieldEmit
instance GHC.Enum.Bounded Fadno.Xml.EmitTypes.DerivesFamily
instance GHC.Enum.Enum Fadno.Xml.EmitTypes.DerivesFamily
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.DerivesFamily
instance Data.Data.Data Fadno.Xml.EmitTypes.DerivesFamily
instance GHC.Show.Show Fadno.Xml.EmitTypes.DerivesFamily
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.DerivesFamily
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.Impl
instance Data.Data.Data Fadno.Xml.EmitTypes.Impl
instance GHC.Show.Show Fadno.Xml.EmitTypes.Impl
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.Impl
instance GHC.Enum.Bounded Fadno.Xml.EmitTypes.CoreType
instance GHC.Enum.Enum Fadno.Xml.EmitTypes.CoreType
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.CoreType
instance Data.Data.Data Fadno.Xml.EmitTypes.CoreType
instance GHC.Show.Show Fadno.Xml.EmitTypes.CoreType
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.CoreType
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.DataTypeEmit
instance Data.Data.Data Fadno.Xml.EmitTypes.DataTypeEmit
instance GHC.Show.Show Fadno.Xml.EmitTypes.DataTypeEmit
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.DataTypeEmit
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.Field
instance Data.Data.Data Fadno.Xml.EmitTypes.Field
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.Field
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.Ctor
instance Data.Data.Data Fadno.Xml.EmitTypes.Ctor
instance GHC.Show.Show Fadno.Xml.EmitTypes.Ctor
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.Ctor
instance GHC.Classes.Ord Fadno.Xml.EmitTypes.Type
instance Data.Data.Data Fadno.Xml.EmitTypes.Type
instance GHC.Show.Show Fadno.Xml.EmitTypes.Type
instance GHC.Classes.Eq Fadno.Xml.EmitTypes.Type
instance GHC.Show.Show Fadno.Xml.EmitTypes.Field


-- | Generate code using types emitted from XSD.
module Fadno.Xml.Codegen

-- | Output all types.
outputTypes :: EmitState -> Output ()

-- | Codegen a type.
outputType :: Type -> Output ()

-- | Output pragmas, module, imports.
outputHeader :: String -> Output ()

-- | Codegen monad.
type Output a = ReaderT OutputEnv (StateT OutputState IO) a

-- | Codegen state.
data OutputState
OutputState :: Map String Name -> OutputState
[_names] :: OutputState -> Map String Name
names :: Iso' OutputState (Map String Name)

-- | Codegen reader environment.
data OutputEnv
OutputEnv :: Handle -> OutputEnv
[_handle] :: OutputEnv -> Handle
handle :: Iso' OutputEnv Handle

-- | Run output monad.
runOut :: OutputEnv -> OutputState -> Output a -> IO (a, OutputState)

-- | Convenience runner.
runOut' :: Handle -> Output a -> IO (a, OutputState)
