models

package
v0.0.0-...-7ac92b4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 7, 2024 License: MIT Imports: 26 Imported by: 0

Documentation

Overview

Default generated models package docs (at least one file is necessary in a models package)

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

Index

Constants

View Source 
const IdentifiersDecls = `
	{{Identifier}} := (&models.{{GeneratedStructName}}{Name: ` + "`" + `{{GeneratedFieldNameValue}}` + "`" + `}).Stage(stage)`
View Source 
const NumberInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = {{GeneratedFieldNameValue}}`
View Source 
const PointerFieldInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = {{GeneratedFieldNameValue}}`
View Source 
const SliceOfPointersFieldInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = append({{Identifier}}.{{GeneratedFieldName}}, {{GeneratedFieldNameValue}})`
View Source 
const StringEnumInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = {{GeneratedFieldNameValue}}`
View Source 
const StringInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = ` + "`" + `{{GeneratedFieldNameValue}}` + "`"
View Source 
const TimeInitStatement = `` /* 129-byte string literal not displayed */

Variables

View Source 
var WSDLUndefinedError = errors.New("Server was unable to process request. --> Object reference not set to an instance of an object.")

Functions

func AfterCreateFromFront 

func AfterCreateFromFront[Type Gongstruct](stage *StageStruct, instance *Type)

AfterCreateFromFront is called after a create from front

func AfterDeleteFromFront 

func AfterDeleteFromFront[Type Gongstruct](stage *StageStruct, staged, front *Type)

AfterDeleteFromFront is called after a delete from front

func AfterReadFromFront 

func AfterReadFromFront[Type Gongstruct](stage *StageStruct, instance *Type)

AfterReadFromFront is called after a Read from front

func AfterUpdateFromFront 

func AfterUpdateFromFront[Type Gongstruct](stage *StageStruct, old, new *Type)

AfterUpdateFromFront is called after a update from front

func CompareGongstructByName 

func CompareGongstructByName[T PointerToGongstruct](a, b T) int

func CopyBranch 

func CopyBranch[Type Gongstruct](from *Type) (to *Type)

CopyBranch stages instance and apply CopyBranch on all gongstruct instances that are referenced by pointers or slices of pointers of the instance

the algorithm stops along the course of graph if a vertex is already staged

func Endpoint 

func Endpoint(w http.ResponseWriter, r *http.Request)

func EvictInOtherSlices 

func EvictInOtherSlices[OwningType PointerToGongstruct, FieldType PointerToGongstruct](
	stage *StageStruct,
	owningInstance OwningType,
	sliceField []FieldType,
	fieldName string)

EvictInOtherSlices allows for adherance between the gong association model and go.

Says you have a Astruct struct with a slice field "anarrayofb []*Bstruct"

go allows many Astruct instance to have the anarrayofb field that have the same pointers. go slices are MANY-MANY association.

With gong it is only ZERO-ONE-MANY associations, a Bstruct can be pointed only once by an Astruct instance through a given field. This follows the requirement that gong is suited for full stack programming and therefore the association is encoded as a reverse pointer (not as a joint table). In gong, a named struct is translated in a table and each table is a named struct.

EvictInOtherSlices removes the fields instances from other fields of other instance

Note : algo is in O(N)log(N) of nb of Astruct and Bstruct instances

func GetAssociationName 

func GetAssociationName[Type Gongstruct]() *Type

GetAssociationName is a generic function that returns an instance of Type where each association is filled with an instance whose name is the name of the association

This function can be handy for generating navigation function that are refactorable

func GetFieldStringValue 

func GetFieldStringValue[Type Gongstruct](instance Type, fieldName string) (res string)

func GetFieldStringValueFromPointer 

func GetFieldStringValueFromPointer[Type PointerToGongstruct](instance Type, fieldName string) (res string)

func GetFields 

func GetFields[Type Gongstruct]() (res []string)

GetFields return the array of the fields

func GetFieldsFromPointer 

func GetFieldsFromPointer[Type PointerToGongstruct]() (res []string)

GetFieldsFromPointer return the array of the fields

func GetGongstrucsSorted 

func GetGongstrucsSorted[T PointerToGongstruct](stage *StageStruct) (sortedSlice []T)

func GetGongstructInstancesMap 

func GetGongstructInstancesMap[Type Gongstruct](stage *StageStruct) *map[string]*Type

GetGongstructInstancesMap returns the map of staged GongstructType instances it is usefull because it allows refactoring of gong struct identifier

func GetGongstructInstancesSet 

func GetGongstructInstancesSet[Type Gongstruct](stage *StageStruct) *map[*Type]any

GetGongstructInstancesSet returns the set staged GongstructType instances it is usefull because it allows refactoring of gongstruct identifier

func GetGongstructInstancesSetFromPointerType 

func GetGongstructInstancesSetFromPointerType[Type PointerToGongstruct](stage *StageStruct) *map[Type]any

GetGongstructInstancesSetFromPointerType returns the set staged GongstructType instances it is usefull because it allows refactoring of gongstruct identifier

func GetGongstructName 

func GetGongstructName[Type Gongstruct]() (res string)

GetGongstructName returns the name of the Gongstruct this can be usefull if one want program robust to refactoring

func GetPointerReverseMap 

func GetPointerReverseMap[Start, End Gongstruct](fieldname string, stage *StageStruct) map[*End][]*Start

GetPointerReverseMap allows backtrack navigation of any Start.Fieldname associations (0..1) that is a pointer from one staged Gongstruct (type Start) instances to another (type End)

The function provides a map with keys as instances of End and values to arrays of *Start the map is construed by iterating over all Start instances and populationg keys with End instances and values with slice of Start instances

func GetPointerToGongstructName 

func GetPointerToGongstructName[Type PointerToGongstruct]() (res string)

GetPointerToGongstructName returns the name of the Gongstruct this can be usefull if one want program robust to refactoring

func GetSliceOfPointersReverseMap 

func GetSliceOfPointersReverseMap[Start, End Gongstruct](fieldname string, stage *StageStruct) map[*End]*Start

GetSliceOfPointersReverseMap allows backtrack navigation of any Start.Fieldname associations (0..N) between one staged Gongstruct instances and many others

The function provides a map with keys as instances of End and values to *Start instances the map is construed by iterating over all Start instances and populating keys with End instances and values with the Start instances

func GongGetMap 

func GongGetMap[Type GongstructMapString](stage *StageStruct) *Type

GongGetMap returns the map of staged GongstructType instances it is usefull because it allows refactoring of gong struct identifier

func GongGetSet 

func GongGetSet[Type GongstructSet](stage *StageStruct) *Type

GongGetSet returns the set staged GongstructType instances it is usefull because it allows refactoring of gong struct identifier

func IntToLetters 

func IntToLetters(number int32) (letters string)

func IsStaged 

func IsStaged[Type Gongstruct](stage *StageStruct, instance *Type) (ok bool)

func ParseAstFile 

func ParseAstFile(stage *StageStruct, pathToFile string) error

ParseAstFile Parse pathToFile and stages all instances declared in the file

func ParseAstFileFromAst 

func ParseAstFileFromAst(stage *StageStruct, inFile *ast.File, fset *token.FileSet) error

ParseAstFile Parse pathToFile and stages all instances declared in the file

func ReplaceOldDeclarationsInFile 

func ReplaceOldDeclarationsInFile(pathToFile string) error

ReplaceOldDeclarationsInFile replaces specific text in a file at the given path.

func Serialize 

func Serialize[Type Gongstruct](stage *StageStruct, tab Tabulator)

func SerializeExcelize 

func SerializeExcelize[Type Gongstruct](stage *StageStruct, f *excelize.File)

func SerializeStage 

func SerializeStage(stage *StageStruct, filename string)

func SetCallbackAfterCreateFromFront 

func SetCallbackAfterCreateFromFront[Type Gongstruct](stage *StageStruct, callback OnAfterCreateInterface[Type])

func SetCallbackAfterDeleteFromFront 

func SetCallbackAfterDeleteFromFront[Type Gongstruct](stage *StageStruct, callback OnAfterDeleteInterface[Type])

func SetCallbackAfterReadFromFront 

func SetCallbackAfterReadFromFront[Type Gongstruct](stage *StageStruct, callback OnAfterReadInterface[Type])

func SetCallbackAfterUpdateFromFront 

func SetCallbackAfterUpdateFromFront[Type Gongstruct](stage *StageStruct, callback OnAfterUpdateInterface[Type])

SetCallbackAfterUpdateFromFront is a function to set up callback that is robust to refactoring

func SetOrchestratorOnAfterUpdate 

func SetOrchestratorOnAfterUpdate[Type Gongstruct](stage *StageStruct)

func SortGongstructSetByName 

func SortGongstructSetByName[T PointerToGongstruct](set map[T]any) (sortedSlice []T)

func StageBranch 

func StageBranch[Type Gongstruct](stage *StageStruct, instance *Type)

StageBranch stages instance and apply StageBranch on all gongstruct instances that are referenced by pointers or slices of pointers of the instance

the algorithm stops along the course of graph if a vertex is already staged

func UnmarshallGongstructStaging 

func UnmarshallGongstructStaging(stage *StageStruct, cmap *ast.CommentMap, assignStmt *ast.AssignStmt, astCoordinate_ string) (
	instance any,
	identifier string,
	gongstructName string,
	fieldName string)

UnmarshallGoStaging unmarshall a go assign statement

func UnstageBranch 

func UnstageBranch[Type Gongstruct](stage *StageStruct, instance *Type)

UnstageBranch stages instance and apply UnstageBranch on all gongstruct instances that are referenced by pointers or slices of pointers of the insance

the algorithm stops along the course of graph if a vertex is already staged

Types

type Above_below 

type Above_below string
const (
	Above_belowAbove Above_below = "above"

	Above_belowBelow Above_below = "below"
)

func (Above_below) CodeValues 

func (above_below Above_below) CodeValues() (res []string)

func (Above_below) Codes 

func (above_below Above_below) Codes() (res []string)

func (*Above_below) FromCodeString 

func (above_below *Above_below) FromCodeString(input string) (err error)

func (*Above_below) FromString 

func (above_below *Above_below) FromString(input string) (err error)

func (*Above_below) ToCodeString 

func (above_below *Above_below) ToCodeString() (res string)

func (Above_below) ToString 

func (above_below Above_below) ToString() (res string)

insertion point of enum utility functions Utility function for Above_below if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Accidental 

type Accidental struct {
	Name  string
	Value *Accidental_value `xml:",chardata" json:"-,"`

	Cautionary *Yes_no `xml:"cautionary,attr,omitempty" json:"cautionary,omitempty"`

	Editorial *Yes_no `xml:"editorial,attr,omitempty" json:"editorial,omitempty"`

	Smufl *Smufl_accidental_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchAccidental 

func CopyBranchAccidental(mapOrigCopy map[any]any, accidentalFrom *Accidental) (accidentalTo *Accidental)

insertion point for stage branch per struct

func (*Accidental) Checkout 

func (accidental *Accidental) Checkout(stage *StageStruct) *Accidental

Checkout accidental to the back repo (if it is already staged)

func (*Accidental) Commit 

func (accidental *Accidental) Commit(stage *StageStruct) *Accidental

commit accidental to the back repo (if it is already staged)

func (*Accidental) CommitVoid 

func (accidental *Accidental) CommitVoid(stage *StageStruct)

func (*Accidental) CopyBasicFields 

func (from *Accidental) CopyBasicFields(to *Accidental)

func (*Accidental) GetName 

func (accidental *Accidental) GetName() (res string)

for satisfaction of GongStruct interface

func (*Accidental) Stage 

func (accidental *Accidental) Stage(stage *StageStruct) *Accidental

insertion point for cumulative sub template with model space calls Stage puts accidental to the model stage

func (*Accidental) Unstage 

func (accidental *Accidental) Unstage(stage *StageStruct) *Accidental

Unstage removes accidental off the model stage

func (*Accidental) UnstageVoid 

func (accidental *Accidental) UnstageVoid(stage *StageStruct)

UnstageVoid removes accidental off the model stage

type Accidental_WOP 

type Accidental_WOP struct {
	// insertion point
	Name string
}

insertion point

type Accidental_mark 

type Accidental_mark struct {
	Name  string
	Value *Accidental_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_accidental_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchAccidental_mark 

func CopyBranchAccidental_mark(mapOrigCopy map[any]any, accidental_markFrom *Accidental_mark) (accidental_markTo *Accidental_mark)

func (*Accidental_mark) Checkout 

func (accidental_mark *Accidental_mark) Checkout(stage *StageStruct) *Accidental_mark

Checkout accidental_mark to the back repo (if it is already staged)

func (*Accidental_mark) Commit 

func (accidental_mark *Accidental_mark) Commit(stage *StageStruct) *Accidental_mark

commit accidental_mark to the back repo (if it is already staged)

func (*Accidental_mark) CommitVoid 

func (accidental_mark *Accidental_mark) CommitVoid(stage *StageStruct)

func (*Accidental_mark) CopyBasicFields 

func (from *Accidental_mark) CopyBasicFields(to *Accidental_mark)

func (*Accidental_mark) GetName 

func (accidental_mark *Accidental_mark) GetName() (res string)

for satisfaction of GongStruct interface

func (*Accidental_mark) Stage 

func (accidental_mark *Accidental_mark) Stage(stage *StageStruct) *Accidental_mark

Stage puts accidental_mark to the model stage

func (*Accidental_mark) Unstage 

func (accidental_mark *Accidental_mark) Unstage(stage *StageStruct) *Accidental_mark

Unstage removes accidental_mark off the model stage

func (*Accidental_mark) UnstageVoid 

func (accidental_mark *Accidental_mark) UnstageVoid(stage *StageStruct)

UnstageVoid removes accidental_mark off the model stage

type Accidental_mark_WOP 

type Accidental_mark_WOP struct {
	// insertion point
	Name string
}

type Accidental_text 

type Accidental_text struct {
	Name  string
	Value *Accidental_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_accidental_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchAccidental_text 

func CopyBranchAccidental_text(mapOrigCopy map[any]any, accidental_textFrom *Accidental_text) (accidental_textTo *Accidental_text)

func (*Accidental_text) Checkout 

func (accidental_text *Accidental_text) Checkout(stage *StageStruct) *Accidental_text

Checkout accidental_text to the back repo (if it is already staged)

func (*Accidental_text) Commit 

func (accidental_text *Accidental_text) Commit(stage *StageStruct) *Accidental_text

commit accidental_text to the back repo (if it is already staged)

func (*Accidental_text) CommitVoid 

func (accidental_text *Accidental_text) CommitVoid(stage *StageStruct)

func (*Accidental_text) CopyBasicFields 

func (from *Accidental_text) CopyBasicFields(to *Accidental_text)

func (*Accidental_text) GetName 

func (accidental_text *Accidental_text) GetName() (res string)

for satisfaction of GongStruct interface

func (*Accidental_text) Stage 

func (accidental_text *Accidental_text) Stage(stage *StageStruct) *Accidental_text

Stage puts accidental_text to the model stage

func (*Accidental_text) Unstage 

func (accidental_text *Accidental_text) Unstage(stage *StageStruct) *Accidental_text

Unstage removes accidental_text off the model stage

func (*Accidental_text) UnstageVoid 

func (accidental_text *Accidental_text) UnstageVoid(stage *StageStruct)

UnstageVoid removes accidental_text off the model stage

type Accidental_text_WOP 

type Accidental_text_WOP struct {
	// insertion point
	Name string
}

type Accidental_value 

type Accidental_value string
const (
	Accidental_valueSharp Accidental_value = "sharp"

	Accidental_valueNatural Accidental_value = "natural"

	Accidental_valueFlat Accidental_value = "flat"

	Accidental_valueDouble_sharp Accidental_value = "double-sharp"

	Accidental_valueSharp_sharp Accidental_value = "sharp-sharp"

	Accidental_valueFlat_flat Accidental_value = "flat-flat"

	Accidental_valueNatural_sharp Accidental_value = "natural-sharp"

	Accidental_valueNatural_flat Accidental_value = "natural-flat"

	Accidental_valueQuarter_flat Accidental_value = "quarter-flat"

	Accidental_valueQuarter_sharp Accidental_value = "quarter-sharp"

	Accidental_valueThree_quarters_flat Accidental_value = "three-quarters-flat"

	Accidental_valueThree_quarters_sharp Accidental_value = "three-quarters-sharp"

	Accidental_valueSharp_down Accidental_value = "sharp-down"

	Accidental_valueSharp_up Accidental_value = "sharp-up"

	Accidental_valueNatural_down Accidental_value = "natural-down"

	Accidental_valueNatural_up Accidental_value = "natural-up"

	Accidental_valueFlat_down Accidental_value = "flat-down"

	Accidental_valueFlat_up Accidental_value = "flat-up"

	Accidental_valueDouble_sharp_down Accidental_value = "double-sharp-down"

	Accidental_valueDouble_sharp_up Accidental_value = "double-sharp-up"

	Accidental_valueFlat_flat_down Accidental_value = "flat-flat-down"

	Accidental_valueFlat_flat_up Accidental_value = "flat-flat-up"

	Accidental_valueArrow_down Accidental_value = "arrow-down"

	Accidental_valueArrow_up Accidental_value = "arrow-up"

	Accidental_valueTriple_sharp Accidental_value = "triple-sharp"

	Accidental_valueTriple_flat Accidental_value = "triple-flat"

	Accidental_valueSlash_quarter_sharp Accidental_value = "slash-quarter-sharp"

	Accidental_valueSlash_sharp Accidental_value = "slash-sharp"

	Accidental_valueSlash_flat Accidental_value = "slash-flat"

	Accidental_valueDouble_slash_flat Accidental_value = "double-slash-flat"

	Accidental_valueSharp_1 Accidental_value = "sharp-1"

	Accidental_valueSharp_2 Accidental_value = "sharp-2"

	Accidental_valueSharp_3 Accidental_value = "sharp-3"

	Accidental_valueSharp_5 Accidental_value = "sharp-5"

	Accidental_valueFlat_1 Accidental_value = "flat-1"

	Accidental_valueFlat_2 Accidental_value = "flat-2"

	Accidental_valueFlat_3 Accidental_value = "flat-3"

	Accidental_valueFlat_4 Accidental_value = "flat-4"

	Accidental_valueSori Accidental_value = "sori"

	Accidental_valueKoron Accidental_value = "koron"

	Accidental_valueOther Accidental_value = "other"
)

func (Accidental_value) CodeValues 

func (accidental_value Accidental_value) CodeValues() (res []string)

func (Accidental_value) Codes 

func (accidental_value Accidental_value) Codes() (res []string)

func (*Accidental_value) FromCodeString 

func (accidental_value *Accidental_value) FromCodeString(input string) (err error)

func (*Accidental_value) FromString 

func (accidental_value *Accidental_value) FromString(input string) (err error)

func (*Accidental_value) ToCodeString 

func (accidental_value *Accidental_value) ToCodeString() (res string)

func (Accidental_value) ToString 

func (accidental_value Accidental_value) ToString() (res string)

Utility function for Accidental_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Accord 

type Accord struct {
	Name string
	// contains filtered or unexported fields
}

func CopyBranchAccord 

func CopyBranchAccord(mapOrigCopy map[any]any, accordFrom *Accord) (accordTo *Accord)

func (*Accord) Checkout 

func (accord *Accord) Checkout(stage *StageStruct) *Accord

Checkout accord to the back repo (if it is already staged)

func (*Accord) Commit 

func (accord *Accord) Commit(stage *StageStruct) *Accord

commit accord to the back repo (if it is already staged)

func (*Accord) CommitVoid 

func (accord *Accord) CommitVoid(stage *StageStruct)

func (*Accord) CopyBasicFields 

func (from *Accord) CopyBasicFields(to *Accord)

func (*Accord) GetName 

func (accord *Accord) GetName() (res string)

for satisfaction of GongStruct interface

func (*Accord) Stage 

func (accord *Accord) Stage(stage *StageStruct) *Accord

Stage puts accord to the model stage

func (*Accord) Unstage 

func (accord *Accord) Unstage(stage *StageStruct) *Accord

Unstage removes accord off the model stage

func (*Accord) UnstageVoid 

func (accord *Accord) UnstageVoid(stage *StageStruct)

UnstageVoid removes accord off the model stage

type Accord_WOP 

type Accord_WOP struct {
	// insertion point
	Name string
}

type Accordion_middle 

type Accordion_middle PositiveInteger

type Accordion_registration 

type Accordion_registration struct {
	Name string

	// The accordion-high element indicates the presence of a dot in
	// the high (4') section of the registration symbol. This element is omitted if
	// no dot is present.
	Accordion_high *Empty `xml:"accordion-high,omitempty" json:"accordion-high,omitempty"`

	// The accordion-middle element indicates the presence of 1 to 3
	// dots in the middle (8') section of the registration symbol. This element is
	// omitted if no dots are present.
	Accordion_middle *Accordion_middle `xml:"accordion-middle,omitempty" json:"accordion-middle,omitempty"`

	// The accordion-low element indicates the presence of a dot in
	// the low (16') section of the registration symbol. This element is omitted if
	// no dot is present.
	Accordion_low *Empty `xml:"accordion-low,omitempty" json:"accordion-low,omitempty"`
}

func CopyBranchAccordion_registration 

func CopyBranchAccordion_registration(mapOrigCopy map[any]any, accordion_registrationFrom *Accordion_registration) (accordion_registrationTo *Accordion_registration)

func (*Accordion_registration) Checkout 

func (accordion_registration *Accordion_registration) Checkout(stage *StageStruct) *Accordion_registration

Checkout accordion_registration to the back repo (if it is already staged)

func (*Accordion_registration) Commit 

func (accordion_registration *Accordion_registration) Commit(stage *StageStruct) *Accordion_registration

commit accordion_registration to the back repo (if it is already staged)

func (*Accordion_registration) CommitVoid 

func (accordion_registration *Accordion_registration) CommitVoid(stage *StageStruct)

func (*Accordion_registration) CopyBasicFields 

func (from *Accordion_registration) CopyBasicFields(to *Accordion_registration)

func (*Accordion_registration) GetName 

func (accordion_registration *Accordion_registration) GetName() (res string)

for satisfaction of GongStruct interface

func (*Accordion_registration) Stage 

func (accordion_registration *Accordion_registration) Stage(stage *StageStruct) *Accordion_registration

Stage puts accordion_registration to the model stage

func (*Accordion_registration) Unstage 

func (accordion_registration *Accordion_registration) Unstage(stage *StageStruct) *Accordion_registration

Unstage removes accordion_registration off the model stage

func (*Accordion_registration) UnstageVoid 

func (accordion_registration *Accordion_registration) UnstageVoid(stage *StageStruct)

UnstageVoid removes accordion_registration off the model stage

type Accordion_registration_WOP 

type Accordion_registration_WOP struct {
	// insertion point
	Name string
}

type AllModelsStructCreateInterface 

type AllModelsStructCreateInterface interface {
	CreateORMAccidental(Accidental *Accidental)
	CreateORMAccidental_mark(Accidental_mark *Accidental_mark)
	CreateORMAccidental_text(Accidental_text *Accidental_text)
	CreateORMAccord(Accord *Accord)
	CreateORMAccordion_registration(Accordion_registration *Accordion_registration)
	CreateORMAnyType(AnyType *AnyType)
	CreateORMAppearance(Appearance *Appearance)
	CreateORMArpeggiate(Arpeggiate *Arpeggiate)
	CreateORMArrow(Arrow *Arrow)
	CreateORMArticulations(Articulations *Articulations)
	CreateORMAssess(Assess *Assess)
	CreateORMAttributes(Attributes *Attributes)
	CreateORMBackup(Backup *Backup)
	CreateORMBar_style_color(Bar_style_color *Bar_style_color)
	CreateORMBarline(Barline *Barline)
	CreateORMBarre(Barre *Barre)
	CreateORMBass(Bass *Bass)
	CreateORMBass_step(Bass_step *Bass_step)
	CreateORMBeam(Beam *Beam)
	CreateORMBeat_repeat(Beat_repeat *Beat_repeat)
	CreateORMBeat_unit_tied(Beat_unit_tied *Beat_unit_tied)
	CreateORMBeater(Beater *Beater)
	CreateORMBend(Bend *Bend)
	CreateORMBookmark(Bookmark *Bookmark)
	CreateORMBracket(Bracket *Bracket)
	CreateORMBreath_mark(Breath_mark *Breath_mark)
	CreateORMCaesura(Caesura *Caesura)
	CreateORMCancel(Cancel *Cancel)
	CreateORMClef(Clef *Clef)
	CreateORMCoda(Coda *Coda)
	CreateORMCredit(Credit *Credit)
	CreateORMDashes(Dashes *Dashes)
	CreateORMDefaults(Defaults *Defaults)
	CreateORMDegree(Degree *Degree)
	CreateORMDegree_alter(Degree_alter *Degree_alter)
	CreateORMDegree_type(Degree_type *Degree_type)
	CreateORMDegree_value(Degree_value *Degree_value)
	CreateORMDirection(Direction *Direction)
	CreateORMDirection_type(Direction_type *Direction_type)
	CreateORMDistance(Distance *Distance)
	CreateORMDouble(Double *Double)
	CreateORMDynamics(Dynamics *Dynamics)
	CreateORMEffect(Effect *Effect)
	CreateORMElision(Elision *Elision)
	CreateORMEmpty(Empty *Empty)
	CreateORMEmpty_font(Empty_font *Empty_font)
	CreateORMEmpty_line(Empty_line *Empty_line)
	CreateORMEmpty_placement(Empty_placement *Empty_placement)
	CreateORMEmpty_placement_smufl(Empty_placement_smufl *Empty_placement_smufl)
	CreateORMEmpty_print_object_style_align(Empty_print_object_style_align *Empty_print_object_style_align)
	CreateORMEmpty_print_style(Empty_print_style *Empty_print_style)
	CreateORMEmpty_print_style_align(Empty_print_style_align *Empty_print_style_align)
	CreateORMEmpty_print_style_align_id(Empty_print_style_align_id *Empty_print_style_align_id)
	CreateORMEmpty_trill_sound(Empty_trill_sound *Empty_trill_sound)
	CreateORMEncoding(Encoding *Encoding)
	CreateORMEnding(Ending *Ending)
	CreateORMExtend(Extend *Extend)
	CreateORMFeature(Feature *Feature)
	CreateORMFermata(Fermata *Fermata)
	CreateORMFigure(Figure *Figure)
	CreateORMFigured_bass(Figured_bass *Figured_bass)
	CreateORMFingering(Fingering *Fingering)
	CreateORMFirst_fret(First_fret *First_fret)
	CreateORMFoo(Foo *Foo)
	CreateORMFor_part(For_part *For_part)
	CreateORMFormatted_symbol(Formatted_symbol *Formatted_symbol)
	CreateORMFormatted_symbol_id(Formatted_symbol_id *Formatted_symbol_id)
	CreateORMForward(Forward *Forward)
	CreateORMFrame(Frame *Frame)
	CreateORMFrame_note(Frame_note *Frame_note)
	CreateORMFret(Fret *Fret)
	CreateORMGlass(Glass *Glass)
	CreateORMGlissando(Glissando *Glissando)
	CreateORMGlyph(Glyph *Glyph)
	CreateORMGrace(Grace *Grace)
	CreateORMGroup_barline(Group_barline *Group_barline)
	CreateORMGroup_symbol(Group_symbol *Group_symbol)
	CreateORMGrouping(Grouping *Grouping)
	CreateORMHammer_on_pull_off(Hammer_on_pull_off *Hammer_on_pull_off)
	CreateORMHandbell(Handbell *Handbell)
	CreateORMHarmon_closed(Harmon_closed *Harmon_closed)
	CreateORMHarmon_mute(Harmon_mute *Harmon_mute)
	CreateORMHarmonic(Harmonic *Harmonic)
	CreateORMHarmony(Harmony *Harmony)
	CreateORMHarmony_alter(Harmony_alter *Harmony_alter)
	CreateORMHarp_pedals(Harp_pedals *Harp_pedals)
	CreateORMHeel_toe(Heel_toe *Heel_toe)
	CreateORMHole(Hole *Hole)
	CreateORMHole_closed(Hole_closed *Hole_closed)
	CreateORMHorizontal_turn(Horizontal_turn *Horizontal_turn)
	CreateORMIdentification(Identification *Identification)
	CreateORMImage(Image *Image)
	CreateORMInstrument(Instrument *Instrument)
	CreateORMInstrument_change(Instrument_change *Instrument_change)
	CreateORMInstrument_link(Instrument_link *Instrument_link)
	CreateORMInterchangeable(Interchangeable *Interchangeable)
	CreateORMInversion(Inversion *Inversion)
	CreateORMKey(Key *Key)
	CreateORMKey_accidental(Key_accidental *Key_accidental)
	CreateORMKey_octave(Key_octave *Key_octave)
	CreateORMKind(Kind *Kind)
	CreateORMLevel(Level *Level)
	CreateORMLine_detail(Line_detail *Line_detail)
	CreateORMLine_width(Line_width *Line_width)
	CreateORMLink(Link *Link)
	CreateORMListen(Listen *Listen)
	CreateORMListening(Listening *Listening)
	CreateORMLyric(Lyric *Lyric)
	CreateORMLyric_font(Lyric_font *Lyric_font)
	CreateORMLyric_language(Lyric_language *Lyric_language)
	CreateORMMeasure_layout(Measure_layout *Measure_layout)
	CreateORMMeasure_numbering(Measure_numbering *Measure_numbering)
	CreateORMMeasure_repeat(Measure_repeat *Measure_repeat)
	CreateORMMeasure_style(Measure_style *Measure_style)
	CreateORMMembrane(Membrane *Membrane)
	CreateORMMetal(Metal *Metal)
	CreateORMMetronome(Metronome *Metronome)
	CreateORMMetronome_beam(Metronome_beam *Metronome_beam)
	CreateORMMetronome_note(Metronome_note *Metronome_note)
	CreateORMMetronome_tied(Metronome_tied *Metronome_tied)
	CreateORMMetronome_tuplet(Metronome_tuplet *Metronome_tuplet)
	CreateORMMidi_device(Midi_device *Midi_device)
	CreateORMMidi_instrument(Midi_instrument *Midi_instrument)
	CreateORMMiscellaneous(Miscellaneous *Miscellaneous)
	CreateORMMiscellaneous_field(Miscellaneous_field *Miscellaneous_field)
	CreateORMMordent(Mordent *Mordent)
	CreateORMMultiple_rest(Multiple_rest *Multiple_rest)
	CreateORMName_display(Name_display *Name_display)
	CreateORMNon_arpeggiate(Non_arpeggiate *Non_arpeggiate)
	CreateORMNotations(Notations *Notations)
	CreateORMNote(Note *Note)
	CreateORMNote_size(Note_size *Note_size)
	CreateORMNote_type(Note_type *Note_type)
	CreateORMNotehead(Notehead *Notehead)
	CreateORMNotehead_text(Notehead_text *Notehead_text)
	CreateORMNumeral(Numeral *Numeral)
	CreateORMNumeral_key(Numeral_key *Numeral_key)
	CreateORMNumeral_root(Numeral_root *Numeral_root)
	CreateORMOctave_shift(Octave_shift *Octave_shift)
	CreateORMOffset(Offset *Offset)
	CreateORMOpus(Opus *Opus)
	CreateORMOrnaments(Ornaments *Ornaments)
	CreateORMOther_appearance(Other_appearance *Other_appearance)
	CreateORMOther_listening(Other_listening *Other_listening)
	CreateORMOther_notation(Other_notation *Other_notation)
	CreateORMOther_play(Other_play *Other_play)
	CreateORMPage_layout(Page_layout *Page_layout)
	CreateORMPage_margins(Page_margins *Page_margins)
	CreateORMPart_clef(Part_clef *Part_clef)
	CreateORMPart_group(Part_group *Part_group)
	CreateORMPart_link(Part_link *Part_link)
	CreateORMPart_list(Part_list *Part_list)
	CreateORMPart_symbol(Part_symbol *Part_symbol)
	CreateORMPart_transpose(Part_transpose *Part_transpose)
	CreateORMPedal(Pedal *Pedal)
	CreateORMPedal_tuning(Pedal_tuning *Pedal_tuning)
	CreateORMPercussion(Percussion *Percussion)
	CreateORMPitch(Pitch *Pitch)
	CreateORMPitched(Pitched *Pitched)
	CreateORMPlay(Play *Play)
	CreateORMPlayer(Player *Player)
	CreateORMPrincipal_voice(Principal_voice *Principal_voice)
	CreateORMPrint(Print *Print)
	CreateORMRelease(Release *Release)
	CreateORMRepeat(Repeat *Repeat)
	CreateORMRest(Rest *Rest)
	CreateORMRoot(Root *Root)
	CreateORMRoot_step(Root_step *Root_step)
	CreateORMScaling(Scaling *Scaling)
	CreateORMScordatura(Scordatura *Scordatura)
	CreateORMScore_instrument(Score_instrument *Score_instrument)
	CreateORMScore_part(Score_part *Score_part)
	CreateORMScore_partwise(Score_partwise *Score_partwise)
	CreateORMScore_timewise(Score_timewise *Score_timewise)
	CreateORMSegno(Segno *Segno)
	CreateORMSlash(Slash *Slash)
	CreateORMSlide(Slide *Slide)
	CreateORMSlur(Slur *Slur)
	CreateORMSound(Sound *Sound)
	CreateORMStaff_details(Staff_details *Staff_details)
	CreateORMStaff_divide(Staff_divide *Staff_divide)
	CreateORMStaff_layout(Staff_layout *Staff_layout)
	CreateORMStaff_size(Staff_size *Staff_size)
	CreateORMStaff_tuning(Staff_tuning *Staff_tuning)
	CreateORMStem(Stem *Stem)
	CreateORMStick(Stick *Stick)
	CreateORMString_mute(String_mute *String_mute)
	CreateORMStrong_accent(Strong_accent *Strong_accent)
	CreateORMSupports(Supports *Supports)
	CreateORMSwing(Swing *Swing)
	CreateORMSync(Sync *Sync)
	CreateORMSystem_dividers(System_dividers *System_dividers)
	CreateORMSystem_layout(System_layout *System_layout)
	CreateORMSystem_margins(System_margins *System_margins)
	CreateORMTap(Tap *Tap)
	CreateORMTechnical(Technical *Technical)
	CreateORMText_element_data(Text_element_data *Text_element_data)
	CreateORMTie(Tie *Tie)
	CreateORMTied(Tied *Tied)
	CreateORMTime(Time *Time)
	CreateORMTime_modification(Time_modification *Time_modification)
	CreateORMTimpani(Timpani *Timpani)
	CreateORMTranspose(Transpose *Transpose)
	CreateORMTremolo(Tremolo *Tremolo)
	CreateORMTuplet(Tuplet *Tuplet)
	CreateORMTuplet_dot(Tuplet_dot *Tuplet_dot)
	CreateORMTuplet_number(Tuplet_number *Tuplet_number)
	CreateORMTuplet_portion(Tuplet_portion *Tuplet_portion)
	CreateORMTuplet_type(Tuplet_type *Tuplet_type)
	CreateORMTyped_text(Typed_text *Typed_text)
	CreateORMUnpitched(Unpitched *Unpitched)
	CreateORMVirtual_instrument(Virtual_instrument *Virtual_instrument)
	CreateORMWait(Wait *Wait)
	CreateORMWavy_line(Wavy_line *Wavy_line)
	CreateORMWedge(Wedge *Wedge)
	CreateORMWood(Wood *Wood)
	CreateORMWork(Work *Work)
}

swagger:ignore

type AllModelsStructDeleteInterface 

type AllModelsStructDeleteInterface interface {
	DeleteORMAccidental(Accidental *Accidental)
	DeleteORMAccidental_mark(Accidental_mark *Accidental_mark)
	DeleteORMAccidental_text(Accidental_text *Accidental_text)
	DeleteORMAccord(Accord *Accord)
	DeleteORMAccordion_registration(Accordion_registration *Accordion_registration)
	DeleteORMAnyType(AnyType *AnyType)
	DeleteORMAppearance(Appearance *Appearance)
	DeleteORMArpeggiate(Arpeggiate *Arpeggiate)
	DeleteORMArrow(Arrow *Arrow)
	DeleteORMArticulations(Articulations *Articulations)
	DeleteORMAssess(Assess *Assess)
	DeleteORMAttributes(Attributes *Attributes)
	DeleteORMBackup(Backup *Backup)
	DeleteORMBar_style_color(Bar_style_color *Bar_style_color)
	DeleteORMBarline(Barline *Barline)
	DeleteORMBarre(Barre *Barre)
	DeleteORMBass(Bass *Bass)
	DeleteORMBass_step(Bass_step *Bass_step)
	DeleteORMBeam(Beam *Beam)
	DeleteORMBeat_repeat(Beat_repeat *Beat_repeat)
	DeleteORMBeat_unit_tied(Beat_unit_tied *Beat_unit_tied)
	DeleteORMBeater(Beater *Beater)
	DeleteORMBend(Bend *Bend)
	DeleteORMBookmark(Bookmark *Bookmark)
	DeleteORMBracket(Bracket *Bracket)
	DeleteORMBreath_mark(Breath_mark *Breath_mark)
	DeleteORMCaesura(Caesura *Caesura)
	DeleteORMCancel(Cancel *Cancel)
	DeleteORMClef(Clef *Clef)
	DeleteORMCoda(Coda *Coda)
	DeleteORMCredit(Credit *Credit)
	DeleteORMDashes(Dashes *Dashes)
	DeleteORMDefaults(Defaults *Defaults)
	DeleteORMDegree(Degree *Degree)
	DeleteORMDegree_alter(Degree_alter *Degree_alter)
	DeleteORMDegree_type(Degree_type *Degree_type)
	DeleteORMDegree_value(Degree_value *Degree_value)
	DeleteORMDirection(Direction *Direction)
	DeleteORMDirection_type(Direction_type *Direction_type)
	DeleteORMDistance(Distance *Distance)
	DeleteORMDouble(Double *Double)
	DeleteORMDynamics(Dynamics *Dynamics)
	DeleteORMEffect(Effect *Effect)
	DeleteORMElision(Elision *Elision)
	DeleteORMEmpty(Empty *Empty)
	DeleteORMEmpty_font(Empty_font *Empty_font)
	DeleteORMEmpty_line(Empty_line *Empty_line)
	DeleteORMEmpty_placement(Empty_placement *Empty_placement)
	DeleteORMEmpty_placement_smufl(Empty_placement_smufl *Empty_placement_smufl)
	DeleteORMEmpty_print_object_style_align(Empty_print_object_style_align *Empty_print_object_style_align)
	DeleteORMEmpty_print_style(Empty_print_style *Empty_print_style)
	DeleteORMEmpty_print_style_align(Empty_print_style_align *Empty_print_style_align)
	DeleteORMEmpty_print_style_align_id(Empty_print_style_align_id *Empty_print_style_align_id)
	DeleteORMEmpty_trill_sound(Empty_trill_sound *Empty_trill_sound)
	DeleteORMEncoding(Encoding *Encoding)
	DeleteORMEnding(Ending *Ending)
	DeleteORMExtend(Extend *Extend)
	DeleteORMFeature(Feature *Feature)
	DeleteORMFermata(Fermata *Fermata)
	DeleteORMFigure(Figure *Figure)
	DeleteORMFigured_bass(Figured_bass *Figured_bass)
	DeleteORMFingering(Fingering *Fingering)
	DeleteORMFirst_fret(First_fret *First_fret)
	DeleteORMFoo(Foo *Foo)
	DeleteORMFor_part(For_part *For_part)
	DeleteORMFormatted_symbol(Formatted_symbol *Formatted_symbol)
	DeleteORMFormatted_symbol_id(Formatted_symbol_id *Formatted_symbol_id)
	DeleteORMForward(Forward *Forward)
	DeleteORMFrame(Frame *Frame)
	DeleteORMFrame_note(Frame_note *Frame_note)
	DeleteORMFret(Fret *Fret)
	DeleteORMGlass(Glass *Glass)
	DeleteORMGlissando(Glissando *Glissando)
	DeleteORMGlyph(Glyph *Glyph)
	DeleteORMGrace(Grace *Grace)
	DeleteORMGroup_barline(Group_barline *Group_barline)
	DeleteORMGroup_symbol(Group_symbol *Group_symbol)
	DeleteORMGrouping(Grouping *Grouping)
	DeleteORMHammer_on_pull_off(Hammer_on_pull_off *Hammer_on_pull_off)
	DeleteORMHandbell(Handbell *Handbell)
	DeleteORMHarmon_closed(Harmon_closed *Harmon_closed)
	DeleteORMHarmon_mute(Harmon_mute *Harmon_mute)
	DeleteORMHarmonic(Harmonic *Harmonic)
	DeleteORMHarmony(Harmony *Harmony)
	DeleteORMHarmony_alter(Harmony_alter *Harmony_alter)
	DeleteORMHarp_pedals(Harp_pedals *Harp_pedals)
	DeleteORMHeel_toe(Heel_toe *Heel_toe)
	DeleteORMHole(Hole *Hole)
	DeleteORMHole_closed(Hole_closed *Hole_closed)
	DeleteORMHorizontal_turn(Horizontal_turn *Horizontal_turn)
	DeleteORMIdentification(Identification *Identification)
	DeleteORMImage(Image *Image)
	DeleteORMInstrument(Instrument *Instrument)
	DeleteORMInstrument_change(Instrument_change *Instrument_change)
	DeleteORMInstrument_link(Instrument_link *Instrument_link)
	DeleteORMInterchangeable(Interchangeable *Interchangeable)
	DeleteORMInversion(Inversion *Inversion)
	DeleteORMKey(Key *Key)
	DeleteORMKey_accidental(Key_accidental *Key_accidental)
	DeleteORMKey_octave(Key_octave *Key_octave)
	DeleteORMKind(Kind *Kind)
	DeleteORMLevel(Level *Level)
	DeleteORMLine_detail(Line_detail *Line_detail)
	DeleteORMLine_width(Line_width *Line_width)
	DeleteORMLink(Link *Link)
	DeleteORMListen(Listen *Listen)
	DeleteORMListening(Listening *Listening)
	DeleteORMLyric(Lyric *Lyric)
	DeleteORMLyric_font(Lyric_font *Lyric_font)
	DeleteORMLyric_language(Lyric_language *Lyric_language)
	DeleteORMMeasure_layout(Measure_layout *Measure_layout)
	DeleteORMMeasure_numbering(Measure_numbering *Measure_numbering)
	DeleteORMMeasure_repeat(Measure_repeat *Measure_repeat)
	DeleteORMMeasure_style(Measure_style *Measure_style)
	DeleteORMMembrane(Membrane *Membrane)
	DeleteORMMetal(Metal *Metal)
	DeleteORMMetronome(Metronome *Metronome)
	DeleteORMMetronome_beam(Metronome_beam *Metronome_beam)
	DeleteORMMetronome_note(Metronome_note *Metronome_note)
	DeleteORMMetronome_tied(Metronome_tied *Metronome_tied)
	DeleteORMMetronome_tuplet(Metronome_tuplet *Metronome_tuplet)
	DeleteORMMidi_device(Midi_device *Midi_device)
	DeleteORMMidi_instrument(Midi_instrument *Midi_instrument)
	DeleteORMMiscellaneous(Miscellaneous *Miscellaneous)
	DeleteORMMiscellaneous_field(Miscellaneous_field *Miscellaneous_field)
	DeleteORMMordent(Mordent *Mordent)
	DeleteORMMultiple_rest(Multiple_rest *Multiple_rest)
	DeleteORMName_display(Name_display *Name_display)
	DeleteORMNon_arpeggiate(Non_arpeggiate *Non_arpeggiate)
	DeleteORMNotations(Notations *Notations)
	DeleteORMNote(Note *Note)
	DeleteORMNote_size(Note_size *Note_size)
	DeleteORMNote_type(Note_type *Note_type)
	DeleteORMNotehead(Notehead *Notehead)
	DeleteORMNotehead_text(Notehead_text *Notehead_text)
	DeleteORMNumeral(Numeral *Numeral)
	DeleteORMNumeral_key(Numeral_key *Numeral_key)
	DeleteORMNumeral_root(Numeral_root *Numeral_root)
	DeleteORMOctave_shift(Octave_shift *Octave_shift)
	DeleteORMOffset(Offset *Offset)
	DeleteORMOpus(Opus *Opus)
	DeleteORMOrnaments(Ornaments *Ornaments)
	DeleteORMOther_appearance(Other_appearance *Other_appearance)
	DeleteORMOther_listening(Other_listening *Other_listening)
	DeleteORMOther_notation(Other_notation *Other_notation)
	DeleteORMOther_play(Other_play *Other_play)
	DeleteORMPage_layout(Page_layout *Page_layout)
	DeleteORMPage_margins(Page_margins *Page_margins)
	DeleteORMPart_clef(Part_clef *Part_clef)
	DeleteORMPart_group(Part_group *Part_group)
	DeleteORMPart_link(Part_link *Part_link)
	DeleteORMPart_list(Part_list *Part_list)
	DeleteORMPart_symbol(Part_symbol *Part_symbol)
	DeleteORMPart_transpose(Part_transpose *Part_transpose)
	DeleteORMPedal(Pedal *Pedal)
	DeleteORMPedal_tuning(Pedal_tuning *Pedal_tuning)
	DeleteORMPercussion(Percussion *Percussion)
	DeleteORMPitch(Pitch *Pitch)
	DeleteORMPitched(Pitched *Pitched)
	DeleteORMPlay(Play *Play)
	DeleteORMPlayer(Player *Player)
	DeleteORMPrincipal_voice(Principal_voice *Principal_voice)
	DeleteORMPrint(Print *Print)
	DeleteORMRelease(Release *Release)
	DeleteORMRepeat(Repeat *Repeat)
	DeleteORMRest(Rest *Rest)
	DeleteORMRoot(Root *Root)
	DeleteORMRoot_step(Root_step *Root_step)
	DeleteORMScaling(Scaling *Scaling)
	DeleteORMScordatura(Scordatura *Scordatura)
	DeleteORMScore_instrument(Score_instrument *Score_instrument)
	DeleteORMScore_part(Score_part *Score_part)
	DeleteORMScore_partwise(Score_partwise *Score_partwise)
	DeleteORMScore_timewise(Score_timewise *Score_timewise)
	DeleteORMSegno(Segno *Segno)
	DeleteORMSlash(Slash *Slash)
	DeleteORMSlide(Slide *Slide)
	DeleteORMSlur(Slur *Slur)
	DeleteORMSound(Sound *Sound)
	DeleteORMStaff_details(Staff_details *Staff_details)
	DeleteORMStaff_divide(Staff_divide *Staff_divide)
	DeleteORMStaff_layout(Staff_layout *Staff_layout)
	DeleteORMStaff_size(Staff_size *Staff_size)
	DeleteORMStaff_tuning(Staff_tuning *Staff_tuning)
	DeleteORMStem(Stem *Stem)
	DeleteORMStick(Stick *Stick)
	DeleteORMString_mute(String_mute *String_mute)
	DeleteORMStrong_accent(Strong_accent *Strong_accent)
	DeleteORMSupports(Supports *Supports)
	DeleteORMSwing(Swing *Swing)
	DeleteORMSync(Sync *Sync)
	DeleteORMSystem_dividers(System_dividers *System_dividers)
	DeleteORMSystem_layout(System_layout *System_layout)
	DeleteORMSystem_margins(System_margins *System_margins)
	DeleteORMTap(Tap *Tap)
	DeleteORMTechnical(Technical *Technical)
	DeleteORMText_element_data(Text_element_data *Text_element_data)
	DeleteORMTie(Tie *Tie)
	DeleteORMTied(Tied *Tied)
	DeleteORMTime(Time *Time)
	DeleteORMTime_modification(Time_modification *Time_modification)
	DeleteORMTimpani(Timpani *Timpani)
	DeleteORMTranspose(Transpose *Transpose)
	DeleteORMTremolo(Tremolo *Tremolo)
	DeleteORMTuplet(Tuplet *Tuplet)
	DeleteORMTuplet_dot(Tuplet_dot *Tuplet_dot)
	DeleteORMTuplet_number(Tuplet_number *Tuplet_number)
	DeleteORMTuplet_portion(Tuplet_portion *Tuplet_portion)
	DeleteORMTuplet_type(Tuplet_type *Tuplet_type)
	DeleteORMTyped_text(Typed_text *Typed_text)
	DeleteORMUnpitched(Unpitched *Unpitched)
	DeleteORMVirtual_instrument(Virtual_instrument *Virtual_instrument)
	DeleteORMWait(Wait *Wait)
	DeleteORMWavy_line(Wavy_line *Wavy_line)
	DeleteORMWedge(Wedge *Wedge)
	DeleteORMWood(Wood *Wood)
	DeleteORMWork(Work *Work)
}

type AnyType 

type AnyType struct {
	Name     string
	InnerXML string `xml:",innerxml"`
}

func CopyBranchAnyType 

func CopyBranchAnyType(mapOrigCopy map[any]any, anytypeFrom *AnyType) (anytypeTo *AnyType)

func (*AnyType) Checkout 

func (anytype *AnyType) Checkout(stage *StageStruct) *AnyType

Checkout anytype to the back repo (if it is already staged)

func (*AnyType) Commit 

func (anytype *AnyType) Commit(stage *StageStruct) *AnyType

commit anytype to the back repo (if it is already staged)

func (*AnyType) CommitVoid 

func (anytype *AnyType) CommitVoid(stage *StageStruct)

func (*AnyType) CopyBasicFields 

func (from *AnyType) CopyBasicFields(to *AnyType)

func (*AnyType) GetName 

func (anytype *AnyType) GetName() (res string)

for satisfaction of GongStruct interface

func (*AnyType) Stage 

func (anytype *AnyType) Stage(stage *StageStruct) *AnyType

Stage puts anytype to the model stage

func (*AnyType) Unstage 

func (anytype *AnyType) Unstage(stage *StageStruct) *AnyType

Unstage removes anytype off the model stage

func (*AnyType) UnstageVoid 

func (anytype *AnyType) UnstageVoid(stage *StageStruct)

UnstageVoid removes anytype off the model stage

type AnyType_WOP 

type AnyType_WOP struct {
	// insertion point
	Name     string
	InnerXML string
}

type AnyURI 

type AnyURI string

func (AnyURI) CodeValues 

func (anyuri AnyURI) CodeValues() (res []string)

func (AnyURI) Codes 

func (anyuri AnyURI) Codes() (res []string)

func (*AnyURI) FromCodeString 

func (anyuri *AnyURI) FromCodeString(input string) (err error)

func (*AnyURI) FromString 

func (anyuri *AnyURI) FromString(input string) (err error)

func (*AnyURI) ToCodeString 

func (anyuri *AnyURI) ToCodeString() (res string)

func (AnyURI) ToString 

func (anyuri AnyURI) ToString() (res string)

Utility function for AnyURI if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Appearance 

type Appearance struct {
	Name       string
	Line_width []*Line_width `xml:"line-width,omitempty" json:"line-width,omitempty"`

	Note_size []*Note_size `xml:"note-size,omitempty" json:"note-size,omitempty"`

	Distance []*Distance `xml:"distance,omitempty" json:"distance,omitempty"`

	Glyph []*Glyph `xml:"glyph,omitempty" json:"glyph,omitempty"`

	Other_appearance []*Other_appearance `xml:"other-appearance,omitempty" json:"other-appearance,omitempty"`
}

func CopyBranchAppearance 

func CopyBranchAppearance(mapOrigCopy map[any]any, appearanceFrom *Appearance) (appearanceTo *Appearance)

func (*Appearance) Checkout 

func (appearance *Appearance) Checkout(stage *StageStruct) *Appearance

Checkout appearance to the back repo (if it is already staged)

func (*Appearance) Commit 

func (appearance *Appearance) Commit(stage *StageStruct) *Appearance

commit appearance to the back repo (if it is already staged)

func (*Appearance) CommitVoid 

func (appearance *Appearance) CommitVoid(stage *StageStruct)

func (*Appearance) CopyBasicFields 

func (from *Appearance) CopyBasicFields(to *Appearance)

func (*Appearance) GetName 

func (appearance *Appearance) GetName() (res string)

for satisfaction of GongStruct interface

func (*Appearance) Stage 

func (appearance *Appearance) Stage(stage *StageStruct) *Appearance

Stage puts appearance to the model stage

func (*Appearance) Unstage 

func (appearance *Appearance) Unstage(stage *StageStruct) *Appearance

Unstage removes appearance off the model stage

func (*Appearance) UnstageVoid 

func (appearance *Appearance) UnstageVoid(stage *StageStruct)

UnstageVoid removes appearance off the model stage

type Appearance_WOP 

type Appearance_WOP struct {
	// insertion point
	Name string
}

type Arpeggiate 

type Arpeggiate struct {
	Name   string
	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`

	Direction *Up_down `xml:"direction,attr,omitempty" json:"direction,omitempty"`

	Unbroken *Yes_no `xml:"unbroken,attr,omitempty" json:"unbroken,omitempty"`
}

func CopyBranchArpeggiate 

func CopyBranchArpeggiate(mapOrigCopy map[any]any, arpeggiateFrom *Arpeggiate) (arpeggiateTo *Arpeggiate)

func (*Arpeggiate) Checkout 

func (arpeggiate *Arpeggiate) Checkout(stage *StageStruct) *Arpeggiate

Checkout arpeggiate to the back repo (if it is already staged)

func (*Arpeggiate) Commit 

func (arpeggiate *Arpeggiate) Commit(stage *StageStruct) *Arpeggiate

commit arpeggiate to the back repo (if it is already staged)

func (*Arpeggiate) CommitVoid 

func (arpeggiate *Arpeggiate) CommitVoid(stage *StageStruct)

func (*Arpeggiate) CopyBasicFields 

func (from *Arpeggiate) CopyBasicFields(to *Arpeggiate)

func (*Arpeggiate) GetName 

func (arpeggiate *Arpeggiate) GetName() (res string)

for satisfaction of GongStruct interface

func (*Arpeggiate) Stage 

func (arpeggiate *Arpeggiate) Stage(stage *StageStruct) *Arpeggiate

Stage puts arpeggiate to the model stage

func (*Arpeggiate) Unstage 

func (arpeggiate *Arpeggiate) Unstage(stage *StageStruct) *Arpeggiate

Unstage removes arpeggiate off the model stage

func (*Arpeggiate) UnstageVoid 

func (arpeggiate *Arpeggiate) UnstageVoid(stage *StageStruct)

UnstageVoid removes arpeggiate off the model stage

type Arpeggiate_WOP 

type Arpeggiate_WOP struct {
	// insertion point
	Name string
}

type Arrow 

type Arrow struct {
	Name           string
	Circular_arrow *Circular_arrow `xml:"circular-arrow,omitempty" json:"circular-arrow,omitempty"`
}

func CopyBranchArrow 

func CopyBranchArrow(mapOrigCopy map[any]any, arrowFrom *Arrow) (arrowTo *Arrow)

func (*Arrow) Checkout 

func (arrow *Arrow) Checkout(stage *StageStruct) *Arrow

Checkout arrow to the back repo (if it is already staged)

func (*Arrow) Commit 

func (arrow *Arrow) Commit(stage *StageStruct) *Arrow

commit arrow to the back repo (if it is already staged)

func (*Arrow) CommitVoid 

func (arrow *Arrow) CommitVoid(stage *StageStruct)

func (*Arrow) CopyBasicFields 

func (from *Arrow) CopyBasicFields(to *Arrow)

func (*Arrow) GetName 

func (arrow *Arrow) GetName() (res string)

for satisfaction of GongStruct interface

func (*Arrow) Stage 

func (arrow *Arrow) Stage(stage *StageStruct) *Arrow

Stage puts arrow to the model stage

func (*Arrow) Unstage 

func (arrow *Arrow) Unstage(stage *StageStruct) *Arrow

Unstage removes arrow off the model stage

func (*Arrow) UnstageVoid 

func (arrow *Arrow) UnstageVoid(stage *StageStruct)

UnstageVoid removes arrow off the model stage

type Arrow_WOP 

type Arrow_WOP struct {
	// insertion point
	Name string
}

type Arrow_direction 

type Arrow_direction string
const (
	Arrow_directionLeft Arrow_direction = "left"

	Arrow_directionUp Arrow_direction = "up"

	Arrow_directionRight Arrow_direction = "right"

	Arrow_directionDown Arrow_direction = "down"

	Arrow_directionNorthwest Arrow_direction = "northwest"

	Arrow_directionNortheast Arrow_direction = "northeast"

	Arrow_directionSoutheast Arrow_direction = "southeast"

	Arrow_directionSouthwest Arrow_direction = "southwest"

	Arrow_directionLeftright Arrow_direction = "left right"

	Arrow_directionUpdown Arrow_direction = "up down"

	Arrow_directionNorthwestsoutheast Arrow_direction = "northwest southeast"

	Arrow_directionNortheastsouthwest Arrow_direction = "northeast southwest"

	Arrow_directionOther Arrow_direction = "other"
)

func (Arrow_direction) CodeValues 

func (arrow_direction Arrow_direction) CodeValues() (res []string)

func (Arrow_direction) Codes 

func (arrow_direction Arrow_direction) Codes() (res []string)

func (*Arrow_direction) FromCodeString 

func (arrow_direction *Arrow_direction) FromCodeString(input string) (err error)

func (*Arrow_direction) FromString 

func (arrow_direction *Arrow_direction) FromString(input string) (err error)

func (*Arrow_direction) ToCodeString 

func (arrow_direction *Arrow_direction) ToCodeString() (res string)

func (Arrow_direction) ToString 

func (arrow_direction Arrow_direction) ToString() (res string)

Utility function for Arrow_direction if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Arrow_style 

type Arrow_style string
const (
	Arrow_styleSingle Arrow_style = "single"

	Arrow_styleDouble Arrow_style = "double"

	Arrow_styleFilled Arrow_style = "filled"

	Arrow_styleHollow Arrow_style = "hollow"

	Arrow_stylePaired Arrow_style = "paired"

	Arrow_styleCombined Arrow_style = "combined"

	Arrow_styleOther Arrow_style = "other"
)

func (Arrow_style) CodeValues 

func (arrow_style Arrow_style) CodeValues() (res []string)

func (Arrow_style) Codes 

func (arrow_style Arrow_style) Codes() (res []string)

func (*Arrow_style) FromCodeString 

func (arrow_style *Arrow_style) FromCodeString(input string) (err error)

func (*Arrow_style) FromString 

func (arrow_style *Arrow_style) FromString(input string) (err error)

func (*Arrow_style) ToCodeString 

func (arrow_style *Arrow_style) ToCodeString() (res string)

func (Arrow_style) ToString 

func (arrow_style Arrow_style) ToString() (res string)

Utility function for Arrow_style if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Articulations 

type Articulations struct {
	Name string

	// The accent element indicates a regular horizontal accent mark.
	Accent *Empty_placement `xml:"accent,omitempty" json:"accent,omitempty"`

	// The strong-accent element indicates a vertical accent mark.
	Strong_accent *Strong_accent `xml:"strong-accent,omitempty" json:"strong-accent,omitempty"`

	// The staccato element is used for a dot articulation, as
	// opposed to a stroke or a wedge.
	Staccato *Empty_placement `xml:"staccato,omitempty" json:"staccato,omitempty"`

	// The tenuto element indicates a tenuto line symbol.
	Tenuto *Empty_placement `xml:"tenuto,omitempty" json:"tenuto,omitempty"`

	// The detached-legato element indicates the combination of a
	// tenuto line and staccato dot symbol.
	Detached_legato *Empty_placement `xml:"detached-legato,omitempty" json:"detached-legato,omitempty"`

	// The staccatissimo element is used for a wedge articulation, as
	// opposed to a dot or a stroke.
	Staccatissimo *Empty_placement `xml:"staccatissimo,omitempty" json:"staccatissimo,omitempty"`

	// The spiccato element is used for a stroke articulation, as
	// opposed to a dot or a wedge.
	Spiccato *Empty_placement `xml:"spiccato,omitempty" json:"spiccato,omitempty"`

	// The scoop element is an indeterminate slide attached to a
	// single note. The scoop appears before the main note and comes from below the
	// main pitch.
	Scoop *Empty_line `xml:"scoop,omitempty" json:"scoop,omitempty"`

	// The plop element is an indeterminate slide attached to a
	// single note. The plop appears before the main note and comes from above the
	// main pitch.
	Plop *Empty_line `xml:"plop,omitempty" json:"plop,omitempty"`

	// The doit element is an indeterminate slide attached to a
	// single note. The doit appears after the main note and goes above the main
	// pitch.
	Doit *Empty_line `xml:"doit,omitempty" json:"doit,omitempty"`

	// The falloff element is an indeterminate slide attached to a
	// single note. The falloff appears after the main note and goes below the main
	// pitch.
	Falloff *Empty_line `xml:"falloff,omitempty" json:"falloff,omitempty"`

	Breath_mark *Breath_mark `xml:"breath-mark,omitempty" json:"breath-mark,omitempty"`

	Caesura *Caesura `xml:"caesura,omitempty" json:"caesura,omitempty"`

	// The stress element indicates a stressed note.
	Stress *Empty_placement `xml:"stress,omitempty" json:"stress,omitempty"`

	// The unstress element indicates an unstressed note. It is often
	// notated using a u-shaped symbol.
	Unstress *Empty_placement `xml:"unstress,omitempty" json:"unstress,omitempty"`

	// The soft-accent element indicates a soft accent that is not as
	// heavy as a normal accent. It is often notated as <>. It can be
	// combined with other articulations to implement the first eight symbols in
	// the SMuFL Articulation supplement range.
	Soft_accent *Empty_placement `xml:"soft-accent,omitempty" json:"soft-accent,omitempty"`

	// The other-articulation element is used to define any
	// articulations not yet in the MusicXML format. The smufl attribute can be
	// used to specify a particular articulation, allowing application
	// interoperability without requiring every SMuFL articulation to have a
	// MusicXML element equivalent. Using the other-articulation element without
	// the smufl attribute allows for extended representation, though without
	// application interoperability.
	Other_articulation *Other_placement_text `xml:"other-articulation,omitempty" json:"other-articulation,omitempty"`
}

func CopyBranchArticulations 

func CopyBranchArticulations(mapOrigCopy map[any]any, articulationsFrom *Articulations) (articulationsTo *Articulations)

func (*Articulations) Checkout 

func (articulations *Articulations) Checkout(stage *StageStruct) *Articulations

Checkout articulations to the back repo (if it is already staged)

func (*Articulations) Commit 

func (articulations *Articulations) Commit(stage *StageStruct) *Articulations

commit articulations to the back repo (if it is already staged)

func (*Articulations) CommitVoid 

func (articulations *Articulations) CommitVoid(stage *StageStruct)

func (*Articulations) CopyBasicFields 

func (from *Articulations) CopyBasicFields(to *Articulations)

func (*Articulations) GetName 

func (articulations *Articulations) GetName() (res string)

for satisfaction of GongStruct interface

func (*Articulations) Stage 

func (articulations *Articulations) Stage(stage *StageStruct) *Articulations

Stage puts articulations to the model stage

func (*Articulations) Unstage 

func (articulations *Articulations) Unstage(stage *StageStruct) *Articulations

Unstage removes articulations off the model stage

func (*Articulations) UnstageVoid 

func (articulations *Articulations) UnstageVoid(stage *StageStruct)

UnstageVoid removes articulations off the model stage

type Articulations_WOP 

type Articulations_WOP struct {
	// insertion point
	Name string
}

type Assess 

type Assess struct {
	Name string
	Type *Yes_no `xml:"type,attr,omitempty" json:"type,omitempty"`

	Player *IDREF `xml:"player,attr,omitempty" json:"player,omitempty"`

	Time_only *Time_only `xml:"time-only,attr,omitempty" json:"time-only,omitempty"`
}

func CopyBranchAssess 

func CopyBranchAssess(mapOrigCopy map[any]any, assessFrom *Assess) (assessTo *Assess)

func (*Assess) Checkout 

func (assess *Assess) Checkout(stage *StageStruct) *Assess

Checkout assess to the back repo (if it is already staged)

func (*Assess) Commit 

func (assess *Assess) Commit(stage *StageStruct) *Assess

commit assess to the back repo (if it is already staged)

func (*Assess) CommitVoid 

func (assess *Assess) CommitVoid(stage *StageStruct)

func (*Assess) CopyBasicFields 

func (from *Assess) CopyBasicFields(to *Assess)

func (*Assess) GetName 

func (assess *Assess) GetName() (res string)

for satisfaction of GongStruct interface

func (*Assess) Stage 

func (assess *Assess) Stage(stage *StageStruct) *Assess

Stage puts assess to the model stage

func (*Assess) Unstage 

func (assess *Assess) Unstage(stage *StageStruct) *Assess

Unstage removes assess off the model stage

func (*Assess) UnstageVoid 

func (assess *Assess) UnstageVoid(stage *StageStruct)

UnstageVoid removes assess off the model stage

type Assess_WOP 

type Assess_WOP struct {
	// insertion point
	Name string
}

type Attributes 

type Attributes struct {
	Name string

	// Musical notation duration is commonly represented as
	// fractions. The divisions element indicates how many divisions per quarter
	// note are used to indicate a note's duration. For example, if duration = 1
	// and divisions = 2, this is an eighth note duration. Duration and divisions
	// are used directly for generating sound output, so they must be chosen to
	// take tuplets into account. Using a divisions element lets us use just one
	// number to represent a duration for each note in the score, while retaining
	// the full power of a fractional representation. If maximum compatibility with
	// Standard MIDI 1.0 files is important, do not have the divisions value exceed
	// 16383.
	Divisions *Positive_divisions `xml:"divisions,omitempty" json:"divisions,omitempty"`

	// The key element 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 []*Key `xml:"key,omitempty" json:"key,omitempty"`

	// The staves element is used if there is more than one staff
	// represented in the given part (e.g., 2 staves for typical piano parts). If
	// absent, a value of 1 is assumed. Staves are ordered from top to bottom in a
	// part in numerical order, with staff 1 above staff 2.
	Staves uint32 `xml:"staves,omitempty" json:"staves,omitempty"`

	// The part-symbol element indicates how a symbol for a
	// multi-staff part is indicated in the score.
	Part_symbol *Part_symbol `xml:"part-symbol,omitempty" json:"part-symbol,omitempty"`

	// The instruments element is only used if more than one
	// instrument is represented in the part (e.g., oboe I and II where they play
	// together most of the time). If absent, a value of 1 is assumed.
	Instruments uint32 `xml:"instruments,omitempty" json:"instruments,omitempty"`

	// Clefs are represented by a combination of sign, line, and
	// clef-octave-change elements.
	Clef []*Clef `xml:"clef,omitempty" json:"clef,omitempty"`

	// The staff-details element is used to indicate different types
	// of staves.
	Staff_details []*Staff_details `xml:"staff-details,omitempty" json:"staff-details,omitempty"`

	Directive []struct {
		Value string `xml:",chardata" json:"-,"`

		EmptyString string `xml:",attr,omitempty" json:",omitempty"`
	} `xml:"directive,omitempty" json:"directive,omitempty"`

	// 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.
	Measure_style []*Measure_style `xml:"measure-style,omitempty" json:"measure-style,omitempty"`

	// If the part is being encoded for a transposing instrument
	// in written vs. concert pitch, the transposition must be encoded in the
	// transpose element using the transpose type.
	Transpose []*Transpose `xml:"transpose,omitempty" json:"transpose,omitempty"`

	// The for-part element is used in a concert score to
	// indicate the transposition for a transposed part created from that
	// score. It is only used in score files that contain a concert-score
	// element in the defaults. This allows concert scores with transposed
	// parts to be represented in a single uncompressed MusicXML file.
	For_part []*For_part `xml:"for-part,omitempty" json:"for-part,omitempty"`
}

func CopyBranchAttributes 

func CopyBranchAttributes(mapOrigCopy map[any]any, attributesFrom *Attributes) (attributesTo *Attributes)

func (*Attributes) Checkout 

func (attributes *Attributes) Checkout(stage *StageStruct) *Attributes

Checkout attributes to the back repo (if it is already staged)

func (*Attributes) Commit 

func (attributes *Attributes) Commit(stage *StageStruct) *Attributes

commit attributes to the back repo (if it is already staged)

func (*Attributes) CommitVoid 

func (attributes *Attributes) CommitVoid(stage *StageStruct)

func (*Attributes) CopyBasicFields 

func (from *Attributes) CopyBasicFields(to *Attributes)

func (*Attributes) GetName 

func (attributes *Attributes) GetName() (res string)

for satisfaction of GongStruct interface

func (*Attributes) Stage 

func (attributes *Attributes) Stage(stage *StageStruct) *Attributes

Stage puts attributes to the model stage

func (*Attributes) Unstage 

func (attributes *Attributes) Unstage(stage *StageStruct) *Attributes

Unstage removes attributes off the model stage

func (*Attributes) UnstageVoid 

func (attributes *Attributes) UnstageVoid(stage *StageStruct)

UnstageVoid removes attributes off the model stage

type Attributes_WOP 

type Attributes_WOP struct {
	// insertion point
	Name string
}

type BackRepoInterface 

type BackRepoInterface interface {
	Commit(stage *StageStruct)
	Checkout(stage *StageStruct)
	Backup(stage *StageStruct, dirPath string)
	Restore(stage *StageStruct, dirPath string)
	BackupXL(stage *StageStruct, dirPath string)
	RestoreXL(stage *StageStruct, dirPath string)
	// insertion point for Commit and Checkout signatures
	CommitAccidental(accidental *Accidental)
	CheckoutAccidental(accidental *Accidental)
	CommitAccidental_mark(accidental_mark *Accidental_mark)
	CheckoutAccidental_mark(accidental_mark *Accidental_mark)
	CommitAccidental_text(accidental_text *Accidental_text)
	CheckoutAccidental_text(accidental_text *Accidental_text)
	CommitAccord(accord *Accord)
	CheckoutAccord(accord *Accord)
	CommitAccordion_registration(accordion_registration *Accordion_registration)
	CheckoutAccordion_registration(accordion_registration *Accordion_registration)
	CommitAnyType(anytype *AnyType)
	CheckoutAnyType(anytype *AnyType)
	CommitAppearance(appearance *Appearance)
	CheckoutAppearance(appearance *Appearance)
	CommitArpeggiate(arpeggiate *Arpeggiate)
	CheckoutArpeggiate(arpeggiate *Arpeggiate)
	CommitArrow(arrow *Arrow)
	CheckoutArrow(arrow *Arrow)
	CommitArticulations(articulations *Articulations)
	CheckoutArticulations(articulations *Articulations)
	CommitAssess(assess *Assess)
	CheckoutAssess(assess *Assess)
	CommitAttributes(attributes *Attributes)
	CheckoutAttributes(attributes *Attributes)
	CommitBackup(backup *Backup)
	CheckoutBackup(backup *Backup)
	CommitBar_style_color(bar_style_color *Bar_style_color)
	CheckoutBar_style_color(bar_style_color *Bar_style_color)
	CommitBarline(barline *Barline)
	CheckoutBarline(barline *Barline)
	CommitBarre(barre *Barre)
	CheckoutBarre(barre *Barre)
	CommitBass(bass *Bass)
	CheckoutBass(bass *Bass)
	CommitBass_step(bass_step *Bass_step)
	CheckoutBass_step(bass_step *Bass_step)
	CommitBeam(beam *Beam)
	CheckoutBeam(beam *Beam)
	CommitBeat_repeat(beat_repeat *Beat_repeat)
	CheckoutBeat_repeat(beat_repeat *Beat_repeat)
	CommitBeat_unit_tied(beat_unit_tied *Beat_unit_tied)
	CheckoutBeat_unit_tied(beat_unit_tied *Beat_unit_tied)
	CommitBeater(beater *Beater)
	CheckoutBeater(beater *Beater)
	CommitBend(bend *Bend)
	CheckoutBend(bend *Bend)
	CommitBookmark(bookmark *Bookmark)
	CheckoutBookmark(bookmark *Bookmark)
	CommitBracket(bracket *Bracket)
	CheckoutBracket(bracket *Bracket)
	CommitBreath_mark(breath_mark *Breath_mark)
	CheckoutBreath_mark(breath_mark *Breath_mark)
	CommitCaesura(caesura *Caesura)
	CheckoutCaesura(caesura *Caesura)
	CommitCancel(cancel *Cancel)
	CheckoutCancel(cancel *Cancel)
	CommitClef(clef *Clef)
	CheckoutClef(clef *Clef)
	CommitCoda(coda *Coda)
	CheckoutCoda(coda *Coda)
	CommitCredit(credit *Credit)
	CheckoutCredit(credit *Credit)
	CommitDashes(dashes *Dashes)
	CheckoutDashes(dashes *Dashes)
	CommitDefaults(defaults *Defaults)
	CheckoutDefaults(defaults *Defaults)
	CommitDegree(degree *Degree)
	CheckoutDegree(degree *Degree)
	CommitDegree_alter(degree_alter *Degree_alter)
	CheckoutDegree_alter(degree_alter *Degree_alter)
	CommitDegree_type(degree_type *Degree_type)
	CheckoutDegree_type(degree_type *Degree_type)
	CommitDegree_value(degree_value *Degree_value)
	CheckoutDegree_value(degree_value *Degree_value)
	CommitDirection(direction *Direction)
	CheckoutDirection(direction *Direction)
	CommitDirection_type(direction_type *Direction_type)
	CheckoutDirection_type(direction_type *Direction_type)
	CommitDistance(distance *Distance)
	CheckoutDistance(distance *Distance)
	CommitDouble(double *Double)
	CheckoutDouble(double *Double)
	CommitDynamics(dynamics *Dynamics)
	CheckoutDynamics(dynamics *Dynamics)
	CommitEffect(effect *Effect)
	CheckoutEffect(effect *Effect)
	CommitElision(elision *Elision)
	CheckoutElision(elision *Elision)
	CommitEmpty(empty *Empty)
	CheckoutEmpty(empty *Empty)
	CommitEmpty_font(empty_font *Empty_font)
	CheckoutEmpty_font(empty_font *Empty_font)
	CommitEmpty_line(empty_line *Empty_line)
	CheckoutEmpty_line(empty_line *Empty_line)
	CommitEmpty_placement(empty_placement *Empty_placement)
	CheckoutEmpty_placement(empty_placement *Empty_placement)
	CommitEmpty_placement_smufl(empty_placement_smufl *Empty_placement_smufl)
	CheckoutEmpty_placement_smufl(empty_placement_smufl *Empty_placement_smufl)
	CommitEmpty_print_object_style_align(empty_print_object_style_align *Empty_print_object_style_align)
	CheckoutEmpty_print_object_style_align(empty_print_object_style_align *Empty_print_object_style_align)
	CommitEmpty_print_style(empty_print_style *Empty_print_style)
	CheckoutEmpty_print_style(empty_print_style *Empty_print_style)
	CommitEmpty_print_style_align(empty_print_style_align *Empty_print_style_align)
	CheckoutEmpty_print_style_align(empty_print_style_align *Empty_print_style_align)
	CommitEmpty_print_style_align_id(empty_print_style_align_id *Empty_print_style_align_id)
	CheckoutEmpty_print_style_align_id(empty_print_style_align_id *Empty_print_style_align_id)
	CommitEmpty_trill_sound(empty_trill_sound *Empty_trill_sound)
	CheckoutEmpty_trill_sound(empty_trill_sound *Empty_trill_sound)
	CommitEncoding(encoding *Encoding)
	CheckoutEncoding(encoding *Encoding)
	CommitEnding(ending *Ending)
	CheckoutEnding(ending *Ending)
	CommitExtend(extend *Extend)
	CheckoutExtend(extend *Extend)
	CommitFeature(feature *Feature)
	CheckoutFeature(feature *Feature)
	CommitFermata(fermata *Fermata)
	CheckoutFermata(fermata *Fermata)
	CommitFigure(figure *Figure)
	CheckoutFigure(figure *Figure)
	CommitFigured_bass(figured_bass *Figured_bass)
	CheckoutFigured_bass(figured_bass *Figured_bass)
	CommitFingering(fingering *Fingering)
	CheckoutFingering(fingering *Fingering)
	CommitFirst_fret(first_fret *First_fret)
	CheckoutFirst_fret(first_fret *First_fret)
	CommitFoo(foo *Foo)
	CheckoutFoo(foo *Foo)
	CommitFor_part(for_part *For_part)
	CheckoutFor_part(for_part *For_part)
	CommitFormatted_symbol(formatted_symbol *Formatted_symbol)
	CheckoutFormatted_symbol(formatted_symbol *Formatted_symbol)
	CommitFormatted_symbol_id(formatted_symbol_id *Formatted_symbol_id)
	CheckoutFormatted_symbol_id(formatted_symbol_id *Formatted_symbol_id)
	CommitForward(forward *Forward)
	CheckoutForward(forward *Forward)
	CommitFrame(frame *Frame)
	CheckoutFrame(frame *Frame)
	CommitFrame_note(frame_note *Frame_note)
	CheckoutFrame_note(frame_note *Frame_note)
	CommitFret(fret *Fret)
	CheckoutFret(fret *Fret)
	CommitGlass(glass *Glass)
	CheckoutGlass(glass *Glass)
	CommitGlissando(glissando *Glissando)
	CheckoutGlissando(glissando *Glissando)
	CommitGlyph(glyph *Glyph)
	CheckoutGlyph(glyph *Glyph)
	CommitGrace(grace *Grace)
	CheckoutGrace(grace *Grace)
	CommitGroup_barline(group_barline *Group_barline)
	CheckoutGroup_barline(group_barline *Group_barline)
	CommitGroup_symbol(group_symbol *Group_symbol)
	CheckoutGroup_symbol(group_symbol *Group_symbol)
	CommitGrouping(grouping *Grouping)
	CheckoutGrouping(grouping *Grouping)
	CommitHammer_on_pull_off(hammer_on_pull_off *Hammer_on_pull_off)
	CheckoutHammer_on_pull_off(hammer_on_pull_off *Hammer_on_pull_off)
	CommitHandbell(handbell *Handbell)
	CheckoutHandbell(handbell *Handbell)
	CommitHarmon_closed(harmon_closed *Harmon_closed)
	CheckoutHarmon_closed(harmon_closed *Harmon_closed)
	CommitHarmon_mute(harmon_mute *Harmon_mute)
	CheckoutHarmon_mute(harmon_mute *Harmon_mute)
	CommitHarmonic(harmonic *Harmonic)
	CheckoutHarmonic(harmonic *Harmonic)
	CommitHarmony(harmony *Harmony)
	CheckoutHarmony(harmony *Harmony)
	CommitHarmony_alter(harmony_alter *Harmony_alter)
	CheckoutHarmony_alter(harmony_alter *Harmony_alter)
	CommitHarp_pedals(harp_pedals *Harp_pedals)
	CheckoutHarp_pedals(harp_pedals *Harp_pedals)
	CommitHeel_toe(heel_toe *Heel_toe)
	CheckoutHeel_toe(heel_toe *Heel_toe)
	CommitHole(hole *Hole)
	CheckoutHole(hole *Hole)
	CommitHole_closed(hole_closed *Hole_closed)
	CheckoutHole_closed(hole_closed *Hole_closed)
	CommitHorizontal_turn(horizontal_turn *Horizontal_turn)
	CheckoutHorizontal_turn(horizontal_turn *Horizontal_turn)
	CommitIdentification(identification *Identification)
	CheckoutIdentification(identification *Identification)
	CommitImage(image *Image)
	CheckoutImage(image *Image)
	CommitInstrument(instrument *Instrument)
	CheckoutInstrument(instrument *Instrument)
	CommitInstrument_change(instrument_change *Instrument_change)
	CheckoutInstrument_change(instrument_change *Instrument_change)
	CommitInstrument_link(instrument_link *Instrument_link)
	CheckoutInstrument_link(instrument_link *Instrument_link)
	CommitInterchangeable(interchangeable *Interchangeable)
	CheckoutInterchangeable(interchangeable *Interchangeable)
	CommitInversion(inversion *Inversion)
	CheckoutInversion(inversion *Inversion)
	CommitKey(key *Key)
	CheckoutKey(key *Key)
	CommitKey_accidental(key_accidental *Key_accidental)
	CheckoutKey_accidental(key_accidental *Key_accidental)
	CommitKey_octave(key_octave *Key_octave)
	CheckoutKey_octave(key_octave *Key_octave)
	CommitKind(kind *Kind)
	CheckoutKind(kind *Kind)
	CommitLevel(level *Level)
	CheckoutLevel(level *Level)
	CommitLine_detail(line_detail *Line_detail)
	CheckoutLine_detail(line_detail *Line_detail)
	CommitLine_width(line_width *Line_width)
	CheckoutLine_width(line_width *Line_width)
	CommitLink(link *Link)
	CheckoutLink(link *Link)
	CommitListen(listen *Listen)
	CheckoutListen(listen *Listen)
	CommitListening(listening *Listening)
	CheckoutListening(listening *Listening)
	CommitLyric(lyric *Lyric)
	CheckoutLyric(lyric *Lyric)
	CommitLyric_font(lyric_font *Lyric_font)
	CheckoutLyric_font(lyric_font *Lyric_font)
	CommitLyric_language(lyric_language *Lyric_language)
	CheckoutLyric_language(lyric_language *Lyric_language)
	CommitMeasure_layout(measure_layout *Measure_layout)
	CheckoutMeasure_layout(measure_layout *Measure_layout)
	CommitMeasure_numbering(measure_numbering *Measure_numbering)
	CheckoutMeasure_numbering(measure_numbering *Measure_numbering)
	CommitMeasure_repeat(measure_repeat *Measure_repeat)
	CheckoutMeasure_repeat(measure_repeat *Measure_repeat)
	CommitMeasure_style(measure_style *Measure_style)
	CheckoutMeasure_style(measure_style *Measure_style)
	CommitMembrane(membrane *Membrane)
	CheckoutMembrane(membrane *Membrane)
	CommitMetal(metal *Metal)
	CheckoutMetal(metal *Metal)
	CommitMetronome(metronome *Metronome)
	CheckoutMetronome(metronome *Metronome)
	CommitMetronome_beam(metronome_beam *Metronome_beam)
	CheckoutMetronome_beam(metronome_beam *Metronome_beam)
	CommitMetronome_note(metronome_note *Metronome_note)
	CheckoutMetronome_note(metronome_note *Metronome_note)
	CommitMetronome_tied(metronome_tied *Metronome_tied)
	CheckoutMetronome_tied(metronome_tied *Metronome_tied)
	CommitMetronome_tuplet(metronome_tuplet *Metronome_tuplet)
	CheckoutMetronome_tuplet(metronome_tuplet *Metronome_tuplet)
	CommitMidi_device(midi_device *Midi_device)
	CheckoutMidi_device(midi_device *Midi_device)
	CommitMidi_instrument(midi_instrument *Midi_instrument)
	CheckoutMidi_instrument(midi_instrument *Midi_instrument)
	CommitMiscellaneous(miscellaneous *Miscellaneous)
	CheckoutMiscellaneous(miscellaneous *Miscellaneous)
	CommitMiscellaneous_field(miscellaneous_field *Miscellaneous_field)
	CheckoutMiscellaneous_field(miscellaneous_field *Miscellaneous_field)
	CommitMordent(mordent *Mordent)
	CheckoutMordent(mordent *Mordent)
	CommitMultiple_rest(multiple_rest *Multiple_rest)
	CheckoutMultiple_rest(multiple_rest *Multiple_rest)
	CommitName_display(name_display *Name_display)
	CheckoutName_display(name_display *Name_display)
	CommitNon_arpeggiate(non_arpeggiate *Non_arpeggiate)
	CheckoutNon_arpeggiate(non_arpeggiate *Non_arpeggiate)
	CommitNotations(notations *Notations)
	CheckoutNotations(notations *Notations)
	CommitNote(note *Note)
	CheckoutNote(note *Note)
	CommitNote_size(note_size *Note_size)
	CheckoutNote_size(note_size *Note_size)
	CommitNote_type(note_type *Note_type)
	CheckoutNote_type(note_type *Note_type)
	CommitNotehead(notehead *Notehead)
	CheckoutNotehead(notehead *Notehead)
	CommitNotehead_text(notehead_text *Notehead_text)
	CheckoutNotehead_text(notehead_text *Notehead_text)
	CommitNumeral(numeral *Numeral)
	CheckoutNumeral(numeral *Numeral)
	CommitNumeral_key(numeral_key *Numeral_key)
	CheckoutNumeral_key(numeral_key *Numeral_key)
	CommitNumeral_root(numeral_root *Numeral_root)
	CheckoutNumeral_root(numeral_root *Numeral_root)
	CommitOctave_shift(octave_shift *Octave_shift)
	CheckoutOctave_shift(octave_shift *Octave_shift)
	CommitOffset(offset *Offset)
	CheckoutOffset(offset *Offset)
	CommitOpus(opus *Opus)
	CheckoutOpus(opus *Opus)
	CommitOrnaments(ornaments *Ornaments)
	CheckoutOrnaments(ornaments *Ornaments)
	CommitOther_appearance(other_appearance *Other_appearance)
	CheckoutOther_appearance(other_appearance *Other_appearance)
	CommitOther_listening(other_listening *Other_listening)
	CheckoutOther_listening(other_listening *Other_listening)
	CommitOther_notation(other_notation *Other_notation)
	CheckoutOther_notation(other_notation *Other_notation)
	CommitOther_play(other_play *Other_play)
	CheckoutOther_play(other_play *Other_play)
	CommitPage_layout(page_layout *Page_layout)
	CheckoutPage_layout(page_layout *Page_layout)
	CommitPage_margins(page_margins *Page_margins)
	CheckoutPage_margins(page_margins *Page_margins)
	CommitPart_clef(part_clef *Part_clef)
	CheckoutPart_clef(part_clef *Part_clef)
	CommitPart_group(part_group *Part_group)
	CheckoutPart_group(part_group *Part_group)
	CommitPart_link(part_link *Part_link)
	CheckoutPart_link(part_link *Part_link)
	CommitPart_list(part_list *Part_list)
	CheckoutPart_list(part_list *Part_list)
	CommitPart_symbol(part_symbol *Part_symbol)
	CheckoutPart_symbol(part_symbol *Part_symbol)
	CommitPart_transpose(part_transpose *Part_transpose)
	CheckoutPart_transpose(part_transpose *Part_transpose)
	CommitPedal(pedal *Pedal)
	CheckoutPedal(pedal *Pedal)
	CommitPedal_tuning(pedal_tuning *Pedal_tuning)
	CheckoutPedal_tuning(pedal_tuning *Pedal_tuning)
	CommitPercussion(percussion *Percussion)
	CheckoutPercussion(percussion *Percussion)
	CommitPitch(pitch *Pitch)
	CheckoutPitch(pitch *Pitch)
	CommitPitched(pitched *Pitched)
	CheckoutPitched(pitched *Pitched)
	CommitPlay(play *Play)
	CheckoutPlay(play *Play)
	CommitPlayer(player *Player)
	CheckoutPlayer(player *Player)
	CommitPrincipal_voice(principal_voice *Principal_voice)
	CheckoutPrincipal_voice(principal_voice *Principal_voice)
	CommitPrint(print *Print)
	CheckoutPrint(print *Print)
	CommitRelease(release *Release)
	CheckoutRelease(release *Release)
	CommitRepeat(repeat *Repeat)
	CheckoutRepeat(repeat *Repeat)
	CommitRest(rest *Rest)
	CheckoutRest(rest *Rest)
	CommitRoot(root *Root)
	CheckoutRoot(root *Root)
	CommitRoot_step(root_step *Root_step)
	CheckoutRoot_step(root_step *Root_step)
	CommitScaling(scaling *Scaling)
	CheckoutScaling(scaling *Scaling)
	CommitScordatura(scordatura *Scordatura)
	CheckoutScordatura(scordatura *Scordatura)
	CommitScore_instrument(score_instrument *Score_instrument)
	CheckoutScore_instrument(score_instrument *Score_instrument)
	CommitScore_part(score_part *Score_part)
	CheckoutScore_part(score_part *Score_part)
	CommitScore_partwise(score_partwise *Score_partwise)
	CheckoutScore_partwise(score_partwise *Score_partwise)
	CommitScore_timewise(score_timewise *Score_timewise)
	CheckoutScore_timewise(score_timewise *Score_timewise)
	CommitSegno(segno *Segno)
	CheckoutSegno(segno *Segno)
	CommitSlash(slash *Slash)
	CheckoutSlash(slash *Slash)
	CommitSlide(slide *Slide)
	CheckoutSlide(slide *Slide)
	CommitSlur(slur *Slur)
	CheckoutSlur(slur *Slur)
	CommitSound(sound *Sound)
	CheckoutSound(sound *Sound)
	CommitStaff_details(staff_details *Staff_details)
	CheckoutStaff_details(staff_details *Staff_details)
	CommitStaff_divide(staff_divide *Staff_divide)
	CheckoutStaff_divide(staff_divide *Staff_divide)
	CommitStaff_layout(staff_layout *Staff_layout)
	CheckoutStaff_layout(staff_layout *Staff_layout)
	CommitStaff_size(staff_size *Staff_size)
	CheckoutStaff_size(staff_size *Staff_size)
	CommitStaff_tuning(staff_tuning *Staff_tuning)
	CheckoutStaff_tuning(staff_tuning *Staff_tuning)
	CommitStem(stem *Stem)
	CheckoutStem(stem *Stem)
	CommitStick(stick *Stick)
	CheckoutStick(stick *Stick)
	CommitString_mute(string_mute *String_mute)
	CheckoutString_mute(string_mute *String_mute)
	CommitStrong_accent(strong_accent *Strong_accent)
	CheckoutStrong_accent(strong_accent *Strong_accent)
	CommitSupports(supports *Supports)
	CheckoutSupports(supports *Supports)
	CommitSwing(swing *Swing)
	CheckoutSwing(swing *Swing)
	CommitSync(sync *Sync)
	CheckoutSync(sync *Sync)
	CommitSystem_dividers(system_dividers *System_dividers)
	CheckoutSystem_dividers(system_dividers *System_dividers)
	CommitSystem_layout(system_layout *System_layout)
	CheckoutSystem_layout(system_layout *System_layout)
	CommitSystem_margins(system_margins *System_margins)
	CheckoutSystem_margins(system_margins *System_margins)
	CommitTap(tap *Tap)
	CheckoutTap(tap *Tap)
	CommitTechnical(technical *Technical)
	CheckoutTechnical(technical *Technical)
	CommitText_element_data(text_element_data *Text_element_data)
	CheckoutText_element_data(text_element_data *Text_element_data)
	CommitTie(tie *Tie)
	CheckoutTie(tie *Tie)
	CommitTied(tied *Tied)
	CheckoutTied(tied *Tied)
	CommitTime(time *Time)
	CheckoutTime(time *Time)
	CommitTime_modification(time_modification *Time_modification)
	CheckoutTime_modification(time_modification *Time_modification)
	CommitTimpani(timpani *Timpani)
	CheckoutTimpani(timpani *Timpani)
	CommitTranspose(transpose *Transpose)
	CheckoutTranspose(transpose *Transpose)
	CommitTremolo(tremolo *Tremolo)
	CheckoutTremolo(tremolo *Tremolo)
	CommitTuplet(tuplet *Tuplet)
	CheckoutTuplet(tuplet *Tuplet)
	CommitTuplet_dot(tuplet_dot *Tuplet_dot)
	CheckoutTuplet_dot(tuplet_dot *Tuplet_dot)
	CommitTuplet_number(tuplet_number *Tuplet_number)
	CheckoutTuplet_number(tuplet_number *Tuplet_number)
	CommitTuplet_portion(tuplet_portion *Tuplet_portion)
	CheckoutTuplet_portion(tuplet_portion *Tuplet_portion)
	CommitTuplet_type(tuplet_type *Tuplet_type)
	CheckoutTuplet_type(tuplet_type *Tuplet_type)
	CommitTyped_text(typed_text *Typed_text)
	CheckoutTyped_text(typed_text *Typed_text)
	CommitUnpitched(unpitched *Unpitched)
	CheckoutUnpitched(unpitched *Unpitched)
	CommitVirtual_instrument(virtual_instrument *Virtual_instrument)
	CheckoutVirtual_instrument(virtual_instrument *Virtual_instrument)
	CommitWait(wait *Wait)
	CheckoutWait(wait *Wait)
	CommitWavy_line(wavy_line *Wavy_line)
	CheckoutWavy_line(wavy_line *Wavy_line)
	CommitWedge(wedge *Wedge)
	CheckoutWedge(wedge *Wedge)
	CommitWood(wood *Wood)
	CheckoutWood(wood *Wood)
	CommitWork(work *Work)
	CheckoutWork(work *Work)
	GetLastCommitFromBackNb() uint
	GetLastPushFromFrontNb() uint
}

type Backup 

type Backup struct {
	Name string
}

func CopyBranchBackup 

func CopyBranchBackup(mapOrigCopy map[any]any, backupFrom *Backup) (backupTo *Backup)

func (*Backup) Checkout 

func (backup *Backup) Checkout(stage *StageStruct) *Backup

Checkout backup to the back repo (if it is already staged)

func (*Backup) Commit 

func (backup *Backup) Commit(stage *StageStruct) *Backup

commit backup to the back repo (if it is already staged)

func (*Backup) CommitVoid 

func (backup *Backup) CommitVoid(stage *StageStruct)

func (*Backup) CopyBasicFields 

func (from *Backup) CopyBasicFields(to *Backup)

func (*Backup) GetName 

func (backup *Backup) GetName() (res string)

for satisfaction of GongStruct interface

func (*Backup) Stage 

func (backup *Backup) Stage(stage *StageStruct) *Backup

Stage puts backup to the model stage

func (*Backup) Unstage 

func (backup *Backup) Unstage(stage *StageStruct) *Backup

Unstage removes backup off the model stage

func (*Backup) UnstageVoid 

func (backup *Backup) UnstageVoid(stage *StageStruct)

UnstageVoid removes backup off the model stage

type Backup_WOP 

type Backup_WOP struct {
	// insertion point
	Name string
}

type Backward_forward 

type Backward_forward string
const (
	Backward_forwardBackward Backward_forward = "backward"

	Backward_forwardForward Backward_forward = "forward"
)

func (Backward_forward) CodeValues 

func (backward_forward Backward_forward) CodeValues() (res []string)

func (Backward_forward) Codes 

func (backward_forward Backward_forward) Codes() (res []string)

func (*Backward_forward) FromCodeString 

func (backward_forward *Backward_forward) FromCodeString(input string) (err error)

func (*Backward_forward) FromString 

func (backward_forward *Backward_forward) FromString(input string) (err error)

func (*Backward_forward) ToCodeString 

func (backward_forward *Backward_forward) ToCodeString() (res string)

func (Backward_forward) ToString 

func (backward_forward Backward_forward) ToString() (res string)

Utility function for Backward_forward if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Bar_style 

type Bar_style string
const (
	Bar_styleRegular Bar_style = "regular"

	Bar_styleDotted Bar_style = "dotted"

	Bar_styleDashed Bar_style = "dashed"

	Bar_styleHeavy Bar_style = "heavy"

	Bar_styleLight_light Bar_style = "light-light"

	Bar_styleLight_heavy Bar_style = "light-heavy"

	Bar_styleHeavy_light Bar_style = "heavy-light"

	Bar_styleHeavy_heavy Bar_style = "heavy-heavy"

	Bar_styleTick Bar_style = "tick"

	Bar_styleShort Bar_style = "short"

	Bar_styleNone Bar_style = "none"
)

func (Bar_style) CodeValues 

func (bar_style Bar_style) CodeValues() (res []string)

func (Bar_style) Codes 

func (bar_style Bar_style) Codes() (res []string)

func (*Bar_style) FromCodeString 

func (bar_style *Bar_style) FromCodeString(input string) (err error)

func (*Bar_style) FromString 

func (bar_style *Bar_style) FromString(input string) (err error)

func (*Bar_style) ToCodeString 

func (bar_style *Bar_style) ToCodeString() (res string)

func (Bar_style) ToString 

func (bar_style Bar_style) ToString() (res string)

Utility function for Bar_style if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Bar_style_color 

type Bar_style_color struct {
	Name    string
	XMLName xml.Name `xml:" bar-style"`

	Value *Bar_style `xml:",chardata" json:"-,"`
}

func CopyBranchBar_style_color 

func CopyBranchBar_style_color(mapOrigCopy map[any]any, bar_style_colorFrom *Bar_style_color) (bar_style_colorTo *Bar_style_color)

func (*Bar_style_color) Checkout 

func (bar_style_color *Bar_style_color) Checkout(stage *StageStruct) *Bar_style_color

Checkout bar_style_color to the back repo (if it is already staged)

func (*Bar_style_color) Commit 

func (bar_style_color *Bar_style_color) Commit(stage *StageStruct) *Bar_style_color

commit bar_style_color to the back repo (if it is already staged)

func (*Bar_style_color) CommitVoid 

func (bar_style_color *Bar_style_color) CommitVoid(stage *StageStruct)

func (*Bar_style_color) CopyBasicFields 

func (from *Bar_style_color) CopyBasicFields(to *Bar_style_color)

func (*Bar_style_color) GetName 

func (bar_style_color *Bar_style_color) GetName() (res string)

for satisfaction of GongStruct interface

func (*Bar_style_color) Stage 

func (bar_style_color *Bar_style_color) Stage(stage *StageStruct) *Bar_style_color

Stage puts bar_style_color to the model stage

func (*Bar_style_color) Unstage 

func (bar_style_color *Bar_style_color) Unstage(stage *StageStruct) *Bar_style_color

Unstage removes bar_style_color off the model stage

func (*Bar_style_color) UnstageVoid 

func (bar_style_color *Bar_style_color) UnstageVoid(stage *StageStruct)

UnstageVoid removes bar_style_color off the model stage

type Bar_style_color_WOP 

type Bar_style_color_WOP struct {
	// insertion point
	Name string
}

type Barline 

type Barline struct {
	Name      string
	Bar_style *Bar_style_color `xml:"bar-style,omitempty" json:"bar-style,omitempty"`

	Wavy_line *Wavy_line `xml:"wavy-line,omitempty" json:"wavy-line,omitempty"`

	Fermata *Fermata `xml:"fermata,omitempty" json:"fermata,omitempty"`

	Ending *Ending `xml:"ending,omitempty" json:"ending,omitempty"`

	Repeat *Repeat `xml:"repeat,omitempty" json:"repeat,omitempty"`

	Location *Right_left_middle `xml:"location,attr,omitempty" json:"location,omitempty"`

	Segno string `xml:"segno,attr,omitempty" json:"segno,omitempty"`

	Coda string `xml:"coda,attr,omitempty" json:"coda,omitempty"`

	Divisions *Divisions `xml:"divisions,attr,omitempty" json:"divisions,omitempty"`
}

func CopyBranchBarline 

func CopyBranchBarline(mapOrigCopy map[any]any, barlineFrom *Barline) (barlineTo *Barline)

func (*Barline) Checkout 

func (barline *Barline) Checkout(stage *StageStruct) *Barline

Checkout barline to the back repo (if it is already staged)

func (*Barline) Commit 

func (barline *Barline) Commit(stage *StageStruct) *Barline

commit barline to the back repo (if it is already staged)

func (*Barline) CommitVoid 

func (barline *Barline) CommitVoid(stage *StageStruct)

func (*Barline) CopyBasicFields 

func (from *Barline) CopyBasicFields(to *Barline)

func (*Barline) GetName 

func (barline *Barline) GetName() (res string)

for satisfaction of GongStruct interface

func (*Barline) Stage 

func (barline *Barline) Stage(stage *StageStruct) *Barline

Stage puts barline to the model stage

func (*Barline) Unstage 

func (barline *Barline) Unstage(stage *StageStruct) *Barline

Unstage removes barline off the model stage

func (*Barline) UnstageVoid 

func (barline *Barline) UnstageVoid(stage *StageStruct)

UnstageVoid removes barline off the model stage

type Barline_WOP 

type Barline_WOP struct {
	// insertion point
	Name  string
	Segno string
	Coda  string
}

type Barre 

type Barre struct {
	Name string
	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchBarre 

func CopyBranchBarre(mapOrigCopy map[any]any, barreFrom *Barre) (barreTo *Barre)

func (*Barre) Checkout 

func (barre *Barre) Checkout(stage *StageStruct) *Barre

Checkout barre to the back repo (if it is already staged)

func (*Barre) Commit 

func (barre *Barre) Commit(stage *StageStruct) *Barre

commit barre to the back repo (if it is already staged)

func (*Barre) CommitVoid 

func (barre *Barre) CommitVoid(stage *StageStruct)

func (*Barre) CopyBasicFields 

func (from *Barre) CopyBasicFields(to *Barre)

func (*Barre) GetName 

func (barre *Barre) GetName() (res string)

for satisfaction of GongStruct interface

func (*Barre) Stage 

func (barre *Barre) Stage(stage *StageStruct) *Barre

Stage puts barre to the model stage

func (*Barre) Unstage 

func (barre *Barre) Unstage(stage *StageStruct) *Barre

Unstage removes barre off the model stage

func (*Barre) UnstageVoid 

func (barre *Barre) UnstageVoid(stage *StageStruct)

UnstageVoid removes barre off the model stage

type Barre_WOP 

type Barre_WOP struct {
	// insertion point
	Name string
}

type Bass 

type Bass struct {
	Name string

	// The optional bass-separator element indicates that text,
	// rather than a line or slash, separates the bass from what precedes it.
	Bass_separator *Style_text `xml:"bass-separator,omitempty" json:"bass-separator,omitempty"`

	Bass_step *Bass_step `xml:"bass-step,omitempty" json:"bass-step,omitempty"`

	// The bass-alter element 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 if not specified.
	Bass_alter *Harmony_alter `xml:"bass-alter,omitempty" json:"bass-alter,omitempty"`

	Arrangement *Harmony_arrangement `xml:"arrangement,attr,omitempty" json:"arrangement,omitempty"`
}

func CopyBranchBass 

func CopyBranchBass(mapOrigCopy map[any]any, bassFrom *Bass) (bassTo *Bass)

func (*Bass) Checkout 

func (bass *Bass) Checkout(stage *StageStruct) *Bass

Checkout bass to the back repo (if it is already staged)

func (*Bass) Commit 

func (bass *Bass) Commit(stage *StageStruct) *Bass

commit bass to the back repo (if it is already staged)

func (*Bass) CommitVoid 

func (bass *Bass) CommitVoid(stage *StageStruct)

func (*Bass) CopyBasicFields 

func (from *Bass) CopyBasicFields(to *Bass)

func (*Bass) GetName 

func (bass *Bass) GetName() (res string)

for satisfaction of GongStruct interface

func (*Bass) Stage 

func (bass *Bass) Stage(stage *StageStruct) *Bass

Stage puts bass to the model stage

func (*Bass) Unstage 

func (bass *Bass) Unstage(stage *StageStruct) *Bass

Unstage removes bass off the model stage

func (*Bass) UnstageVoid 

func (bass *Bass) UnstageVoid(stage *StageStruct)

UnstageVoid removes bass off the model stage

type Bass_WOP 

type Bass_WOP struct {
	// insertion point
	Name string
}

type Bass_step 

type Bass_step struct {
	Name  string
	Value *Step `xml:",chardata" json:"-,"`

	Text string `xml:"text,attr,omitempty" json:"text,omitempty"`
}

func CopyBranchBass_step 

func CopyBranchBass_step(mapOrigCopy map[any]any, bass_stepFrom *Bass_step) (bass_stepTo *Bass_step)

func (*Bass_step) Checkout 

func (bass_step *Bass_step) Checkout(stage *StageStruct) *Bass_step

Checkout bass_step to the back repo (if it is already staged)

func (*Bass_step) Commit 

func (bass_step *Bass_step) Commit(stage *StageStruct) *Bass_step

commit bass_step to the back repo (if it is already staged)

func (*Bass_step) CommitVoid 

func (bass_step *Bass_step) CommitVoid(stage *StageStruct)

func (*Bass_step) CopyBasicFields 

func (from *Bass_step) CopyBasicFields(to *Bass_step)

func (*Bass_step) GetName 

func (bass_step *Bass_step) GetName() (res string)

for satisfaction of GongStruct interface

func (*Bass_step) Stage 

func (bass_step *Bass_step) Stage(stage *StageStruct) *Bass_step

Stage puts bass_step to the model stage

func (*Bass_step) Unstage 

func (bass_step *Bass_step) Unstage(stage *StageStruct) *Bass_step

Unstage removes bass_step off the model stage

func (*Bass_step) UnstageVoid 

func (bass_step *Bass_step) UnstageVoid(stage *StageStruct)

UnstageVoid removes bass_step off the model stage

type Bass_step_WOP 

type Bass_step_WOP struct {
	// insertion point
	Name string
	Text string
}

type Beam 

type Beam struct {
	Name  string
	Value *Beam_value `xml:",chardata" json:"-,"`

	Number *Beam_level `xml:"number,attr,omitempty" json:"number,omitempty"`

	Repeater *Yes_no `xml:"repeater,attr,omitempty" json:"repeater,omitempty"`

	Fan *Fan `xml:"fan,attr,omitempty" json:"fan,omitempty"`
}

func CopyBranchBeam 

func CopyBranchBeam(mapOrigCopy map[any]any, beamFrom *Beam) (beamTo *Beam)

func (*Beam) Checkout 

func (beam *Beam) Checkout(stage *StageStruct) *Beam

Checkout beam to the back repo (if it is already staged)

func (*Beam) Commit 

func (beam *Beam) Commit(stage *StageStruct) *Beam

commit beam to the back repo (if it is already staged)

func (*Beam) CommitVoid 

func (beam *Beam) CommitVoid(stage *StageStruct)

func (*Beam) CopyBasicFields 

func (from *Beam) CopyBasicFields(to *Beam)

func (*Beam) GetName 

func (beam *Beam) GetName() (res string)

for satisfaction of GongStruct interface

func (*Beam) Stage 

func (beam *Beam) Stage(stage *StageStruct) *Beam

Stage puts beam to the model stage

func (*Beam) Unstage 

func (beam *Beam) Unstage(stage *StageStruct) *Beam

Unstage removes beam off the model stage

func (*Beam) UnstageVoid 

func (beam *Beam) UnstageVoid(stage *StageStruct)

UnstageVoid removes beam off the model stage

type Beam_WOP 

type Beam_WOP struct {
	// insertion point
	Name string
}

type Beam_level 

type Beam_level PositiveInteger

type Beam_value 

type Beam_value string
const (
	Beam_valueBegin Beam_value = "begin"

	Beam_valueContinue_ Beam_value = "continue"

	Beam_valueEnd Beam_value = "end"

	Beam_valueForwardhook Beam_value = "forward hook"

	Beam_valueBackwardhook Beam_value = "backward hook"
)

func (Beam_value) CodeValues 

func (beam_value Beam_value) CodeValues() (res []string)

func (Beam_value) Codes 

func (beam_value Beam_value) Codes() (res []string)

func (*Beam_value) FromCodeString 

func (beam_value *Beam_value) FromCodeString(input string) (err error)

func (*Beam_value) FromString 

func (beam_value *Beam_value) FromString(input string) (err error)

func (*Beam_value) ToCodeString 

func (beam_value *Beam_value) ToCodeString() (res string)

func (Beam_value) ToString 

func (beam_value Beam_value) ToString() (res string)

Utility function for Beam_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Beat_repeat 

type Beat_repeat struct {
	Name string
	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Slashes *PositiveInteger `xml:"slashes,attr,omitempty" json:"slashes,omitempty"`

	Use_dots *Yes_no `xml:"use-dots,attr,omitempty" json:"use-dots,omitempty"`
}

func CopyBranchBeat_repeat 

func CopyBranchBeat_repeat(mapOrigCopy map[any]any, beat_repeatFrom *Beat_repeat) (beat_repeatTo *Beat_repeat)

func (*Beat_repeat) Checkout 

func (beat_repeat *Beat_repeat) Checkout(stage *StageStruct) *Beat_repeat

Checkout beat_repeat to the back repo (if it is already staged)

func (*Beat_repeat) Commit 

func (beat_repeat *Beat_repeat) Commit(stage *StageStruct) *Beat_repeat

commit beat_repeat to the back repo (if it is already staged)

func (*Beat_repeat) CommitVoid 

func (beat_repeat *Beat_repeat) CommitVoid(stage *StageStruct)

func (*Beat_repeat) CopyBasicFields 

func (from *Beat_repeat) CopyBasicFields(to *Beat_repeat)

func (*Beat_repeat) GetName 

func (beat_repeat *Beat_repeat) GetName() (res string)

for satisfaction of GongStruct interface

func (*Beat_repeat) Stage 

func (beat_repeat *Beat_repeat) Stage(stage *StageStruct) *Beat_repeat

Stage puts beat_repeat to the model stage

func (*Beat_repeat) Unstage 

func (beat_repeat *Beat_repeat) Unstage(stage *StageStruct) *Beat_repeat

Unstage removes beat_repeat off the model stage

func (*Beat_repeat) UnstageVoid 

func (beat_repeat *Beat_repeat) UnstageVoid(stage *StageStruct)

UnstageVoid removes beat_repeat off the model stage

type Beat_repeat_WOP 

type Beat_repeat_WOP struct {
	// insertion point
	Name string
}

type Beat_unit_tied 

type Beat_unit_tied struct {
	Name string
}

func CopyBranchBeat_unit_tied 

func CopyBranchBeat_unit_tied(mapOrigCopy map[any]any, beat_unit_tiedFrom *Beat_unit_tied) (beat_unit_tiedTo *Beat_unit_tied)

func (*Beat_unit_tied) Checkout 

func (beat_unit_tied *Beat_unit_tied) Checkout(stage *StageStruct) *Beat_unit_tied

Checkout beat_unit_tied to the back repo (if it is already staged)

func (*Beat_unit_tied) Commit 

func (beat_unit_tied *Beat_unit_tied) Commit(stage *StageStruct) *Beat_unit_tied

commit beat_unit_tied to the back repo (if it is already staged)

func (*Beat_unit_tied) CommitVoid 

func (beat_unit_tied *Beat_unit_tied) CommitVoid(stage *StageStruct)

func (*Beat_unit_tied) CopyBasicFields 

func (from *Beat_unit_tied) CopyBasicFields(to *Beat_unit_tied)

func (*Beat_unit_tied) GetName 

func (beat_unit_tied *Beat_unit_tied) GetName() (res string)

for satisfaction of GongStruct interface

func (*Beat_unit_tied) Stage 

func (beat_unit_tied *Beat_unit_tied) Stage(stage *StageStruct) *Beat_unit_tied

Stage puts beat_unit_tied to the model stage

func (*Beat_unit_tied) Unstage 

func (beat_unit_tied *Beat_unit_tied) Unstage(stage *StageStruct) *Beat_unit_tied

Unstage removes beat_unit_tied off the model stage

func (*Beat_unit_tied) UnstageVoid 

func (beat_unit_tied *Beat_unit_tied) UnstageVoid(stage *StageStruct)

UnstageVoid removes beat_unit_tied off the model stage

type Beat_unit_tied_WOP 

type Beat_unit_tied_WOP struct {
	// insertion point
	Name string
}

type Beater 

type Beater struct {
	Name  string
	Value *Beater_value `xml:",chardata" json:"-,"`

	Tip *Tip_direction `xml:"tip,attr,omitempty" json:"tip,omitempty"`
}

func CopyBranchBeater 

func CopyBranchBeater(mapOrigCopy map[any]any, beaterFrom *Beater) (beaterTo *Beater)

func (*Beater) Checkout 

func (beater *Beater) Checkout(stage *StageStruct) *Beater

Checkout beater to the back repo (if it is already staged)

func (*Beater) Commit 

func (beater *Beater) Commit(stage *StageStruct) *Beater

commit beater to the back repo (if it is already staged)

func (*Beater) CommitVoid 

func (beater *Beater) CommitVoid(stage *StageStruct)

func (*Beater) CopyBasicFields 

func (from *Beater) CopyBasicFields(to *Beater)

func (*Beater) GetName 

func (beater *Beater) GetName() (res string)

for satisfaction of GongStruct interface

func (*Beater) Stage 

func (beater *Beater) Stage(stage *StageStruct) *Beater

Stage puts beater to the model stage

func (*Beater) Unstage 

func (beater *Beater) Unstage(stage *StageStruct) *Beater

Unstage removes beater off the model stage

func (*Beater) UnstageVoid 

func (beater *Beater) UnstageVoid(stage *StageStruct)

UnstageVoid removes beater off the model stage

type Beater_WOP 

type Beater_WOP struct {
	// insertion point
	Name string
}

type Beater_value 

type Beater_value string
const (
	Beater_valueBow Beater_value = "bow"

	Beater_valueChimehammer Beater_value = "chime hammer"

	Beater_valueCoin Beater_value = "coin"

	Beater_valueDrumstick Beater_value = "drum stick"

	Beater_valueFinger Beater_value = "finger"

	Beater_valueFingernail Beater_value = "fingernail"

	Beater_valueFist Beater_value = "fist"

	Beater_valueGuiroscraper Beater_value = "guiro scraper"

	Beater_valueHammer Beater_value = "hammer"

	Beater_valueHand Beater_value = "hand"

	Beater_valueJazzstick Beater_value = "jazz stick"

	Beater_valueKnittingneedle Beater_value = "knitting needle"

	Beater_valueMetalhammer Beater_value = "metal hammer"

	Beater_valueSlidebrushongong Beater_value = "slide brush on gong"

	Beater_valueSnarestick Beater_value = "snare stick"

	Beater_valueSpoonmallet Beater_value = "spoon mallet"

	Beater_valueSuperball Beater_value = "superball"

	Beater_valueTrianglebeater Beater_value = "triangle beater"

	Beater_valueTrianglebeaterplain Beater_value = "triangle beater plain"

	Beater_valueWirebrush Beater_value = "wire brush"
)

func (Beater_value) CodeValues 

func (beater_value Beater_value) CodeValues() (res []string)

func (Beater_value) Codes 

func (beater_value Beater_value) Codes() (res []string)

func (*Beater_value) FromCodeString 

func (beater_value *Beater_value) FromCodeString(input string) (err error)

func (*Beater_value) FromString 

func (beater_value *Beater_value) FromString(input string) (err error)

func (*Beater_value) ToCodeString 

func (beater_value *Beater_value) ToCodeString() (res string)

func (Beater_value) ToString 

func (beater_value Beater_value) ToString() (res string)

Utility function for Beater_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Bend 

type Bend struct {
	Name string

	// The bend-alter element indicates the number of semitones in
	// the bend, similar to the alter element. As with the alter element, numbers
	// like 0.5 can be used to indicate microtones. Negative values indicate
	// pre-bends or releases. The pre-bend and release elements are used to
	// distinguish what is intended. Because the bend-alter element represents the
	// number of steps in the bend, a release after a bend has a negative
	// bend-alter value, not a zero value.
	Bend_alter *Semitones `xml:"bend-alter,omitempty" json:"bend-alter,omitempty"`

	// The 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. Content values of "scoop" and "dip"
	// refer to the SMuFL guitarVibratoBarScoop and guitarVibratoBarDip glyphs.
	With_bar *Placement_text `xml:"with-bar,omitempty" json:"with-bar,omitempty"`

	// The pre-bend element indicates that a bend is a pre-bend
	// rather than a normal bend or a release.
	Pre_bend *Empty `xml:"pre-bend,omitempty" json:"pre-bend,omitempty"`

	Release *Release `xml:"release,omitempty" json:"release,omitempty"`

	Shape *Bend_shape `xml:"shape,attr,omitempty" json:"shape,omitempty"`
}

func CopyBranchBend 

func CopyBranchBend(mapOrigCopy map[any]any, bendFrom *Bend) (bendTo *Bend)

func (*Bend) Checkout 

func (bend *Bend) Checkout(stage *StageStruct) *Bend

Checkout bend to the back repo (if it is already staged)

func (*Bend) Commit 

func (bend *Bend) Commit(stage *StageStruct) *Bend

commit bend to the back repo (if it is already staged)

func (*Bend) CommitVoid 

func (bend *Bend) CommitVoid(stage *StageStruct)

func (*Bend) CopyBasicFields 

func (from *Bend) CopyBasicFields(to *Bend)

func (*Bend) GetName 

func (bend *Bend) GetName() (res string)

for satisfaction of GongStruct interface

func (*Bend) Stage 

func (bend *Bend) Stage(stage *StageStruct) *Bend

Stage puts bend to the model stage

func (*Bend) Unstage 

func (bend *Bend) Unstage(stage *StageStruct) *Bend

Unstage removes bend off the model stage

func (*Bend) UnstageVoid 

func (bend *Bend) UnstageVoid(stage *StageStruct)

UnstageVoid removes bend off the model stage

type Bend_WOP 

type Bend_WOP struct {
	// insertion point
	Name string
}

type Bend_shape 

type Bend_shape string
const (
	Bend_shapeAngled Bend_shape = "angled"

	Bend_shapeCurved Bend_shape = "curved"
)

func (Bend_shape) CodeValues 

func (bend_shape Bend_shape) CodeValues() (res []string)

func (Bend_shape) Codes 

func (bend_shape Bend_shape) Codes() (res []string)

func (*Bend_shape) FromCodeString 

func (bend_shape *Bend_shape) FromCodeString(input string) (err error)

func (*Bend_shape) FromString 

func (bend_shape *Bend_shape) FromString(input string) (err error)

func (*Bend_shape) ToCodeString 

func (bend_shape *Bend_shape) ToCodeString() (res string)

func (Bend_shape) ToString 

func (bend_shape Bend_shape) ToString() (res string)

Utility function for Bend_shape if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Bookmark 

type Bookmark struct {
	Id *ID_MUSICXML `xml:"id,attr,omitempty" json:"id,omitempty"`

	Name string `xml:"name,attr,omitempty" json:"name,omitempty"`
}

func CopyBranchBookmark 

func CopyBranchBookmark(mapOrigCopy map[any]any, bookmarkFrom *Bookmark) (bookmarkTo *Bookmark)

func (*Bookmark) Checkout 

func (bookmark *Bookmark) Checkout(stage *StageStruct) *Bookmark

Checkout bookmark to the back repo (if it is already staged)

func (*Bookmark) Commit 

func (bookmark *Bookmark) Commit(stage *StageStruct) *Bookmark

commit bookmark to the back repo (if it is already staged)

func (*Bookmark) CommitVoid 

func (bookmark *Bookmark) CommitVoid(stage *StageStruct)

func (*Bookmark) CopyBasicFields 

func (from *Bookmark) CopyBasicFields(to *Bookmark)

func (*Bookmark) GetName 

func (bookmark *Bookmark) GetName() (res string)

for satisfaction of GongStruct interface

func (*Bookmark) Stage 

func (bookmark *Bookmark) Stage(stage *StageStruct) *Bookmark

Stage puts bookmark to the model stage

func (*Bookmark) Unstage 

func (bookmark *Bookmark) Unstage(stage *StageStruct) *Bookmark

Unstage removes bookmark off the model stage

func (*Bookmark) UnstageVoid 

func (bookmark *Bookmark) UnstageVoid(stage *StageStruct)

UnstageVoid removes bookmark off the model stage

type Bookmark_WOP 

type Bookmark_WOP struct {
	// insertion point
	Name string
}

type Bracket 

type Bracket struct {
	Name string
	Type *Start_stop_continue `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`

	Line_end *Line_end `xml:"line-end,attr,omitempty" json:"line-end,omitempty"`

	End_length *Tenths `xml:"end-length,attr,omitempty" json:"end-length,omitempty"`
}

func CopyBranchBracket 

func CopyBranchBracket(mapOrigCopy map[any]any, bracketFrom *Bracket) (bracketTo *Bracket)

func (*Bracket) Checkout 

func (bracket *Bracket) Checkout(stage *StageStruct) *Bracket

Checkout bracket to the back repo (if it is already staged)

func (*Bracket) Commit 

func (bracket *Bracket) Commit(stage *StageStruct) *Bracket

commit bracket to the back repo (if it is already staged)

func (*Bracket) CommitVoid 

func (bracket *Bracket) CommitVoid(stage *StageStruct)

func (*Bracket) CopyBasicFields 

func (from *Bracket) CopyBasicFields(to *Bracket)

func (*Bracket) GetName 

func (bracket *Bracket) GetName() (res string)

for satisfaction of GongStruct interface

func (*Bracket) Stage 

func (bracket *Bracket) Stage(stage *StageStruct) *Bracket

Stage puts bracket to the model stage

func (*Bracket) Unstage 

func (bracket *Bracket) Unstage(stage *StageStruct) *Bracket

Unstage removes bracket off the model stage

func (*Bracket) UnstageVoid 

func (bracket *Bracket) UnstageVoid(stage *StageStruct)

UnstageVoid removes bracket off the model stage

type Bracket_WOP 

type Bracket_WOP struct {
	// insertion point
	Name string
}

type Breath_mark 

type Breath_mark struct {
	Name  string
	Value *Breath_mark_value `xml:",chardata" json:"-,"`
}

func CopyBranchBreath_mark 

func CopyBranchBreath_mark(mapOrigCopy map[any]any, breath_markFrom *Breath_mark) (breath_markTo *Breath_mark)

func (*Breath_mark) Checkout 

func (breath_mark *Breath_mark) Checkout(stage *StageStruct) *Breath_mark

Checkout breath_mark to the back repo (if it is already staged)

func (*Breath_mark) Commit 

func (breath_mark *Breath_mark) Commit(stage *StageStruct) *Breath_mark

commit breath_mark to the back repo (if it is already staged)

func (*Breath_mark) CommitVoid 

func (breath_mark *Breath_mark) CommitVoid(stage *StageStruct)

func (*Breath_mark) CopyBasicFields 

func (from *Breath_mark) CopyBasicFields(to *Breath_mark)

func (*Breath_mark) GetName 

func (breath_mark *Breath_mark) GetName() (res string)

for satisfaction of GongStruct interface

func (*Breath_mark) Stage 

func (breath_mark *Breath_mark) Stage(stage *StageStruct) *Breath_mark

Stage puts breath_mark to the model stage

func (*Breath_mark) Unstage 

func (breath_mark *Breath_mark) Unstage(stage *StageStruct) *Breath_mark

Unstage removes breath_mark off the model stage

func (*Breath_mark) UnstageVoid 

func (breath_mark *Breath_mark) UnstageVoid(stage *StageStruct)

UnstageVoid removes breath_mark off the model stage

type Breath_mark_WOP 

type Breath_mark_WOP struct {
	// insertion point
	Name string
}

type Breath_mark_value 

type Breath_mark_value string
const (
	Breath_mark_valueEmptyString Breath_mark_value = ""

	Breath_mark_valueComma Breath_mark_value = "comma"

	Breath_mark_valueTick Breath_mark_value = "tick"

	Breath_mark_valueUpbow Breath_mark_value = "upbow"

	Breath_mark_valueSalzedo Breath_mark_value = "salzedo"
)

func (Breath_mark_value) CodeValues 

func (breath_mark_value Breath_mark_value) CodeValues() (res []string)

func (Breath_mark_value) Codes 

func (breath_mark_value Breath_mark_value) Codes() (res []string)

func (*Breath_mark_value) FromCodeString 

func (breath_mark_value *Breath_mark_value) FromCodeString(input string) (err error)

func (*Breath_mark_value) FromString 

func (breath_mark_value *Breath_mark_value) FromString(input string) (err error)

func (*Breath_mark_value) ToCodeString 

func (breath_mark_value *Breath_mark_value) ToCodeString() (res string)

func (Breath_mark_value) ToString 

func (breath_mark_value Breath_mark_value) ToString() (res string)

Utility function for Breath_mark_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Caesura 

type Caesura struct {
	Name  string
	Value *Caesura_value `xml:",chardata" json:"-,"`
}

func CopyBranchCaesura 

func CopyBranchCaesura(mapOrigCopy map[any]any, caesuraFrom *Caesura) (caesuraTo *Caesura)

func (*Caesura) Checkout 

func (caesura *Caesura) Checkout(stage *StageStruct) *Caesura

Checkout caesura to the back repo (if it is already staged)

func (*Caesura) Commit 

func (caesura *Caesura) Commit(stage *StageStruct) *Caesura

commit caesura to the back repo (if it is already staged)

func (*Caesura) CommitVoid 

func (caesura *Caesura) CommitVoid(stage *StageStruct)

func (*Caesura) CopyBasicFields 

func (from *Caesura) CopyBasicFields(to *Caesura)

func (*Caesura) GetName 

func (caesura *Caesura) GetName() (res string)

for satisfaction of GongStruct interface

func (*Caesura) Stage 

func (caesura *Caesura) Stage(stage *StageStruct) *Caesura

Stage puts caesura to the model stage

func (*Caesura) Unstage 

func (caesura *Caesura) Unstage(stage *StageStruct) *Caesura

Unstage removes caesura off the model stage

func (*Caesura) UnstageVoid 

func (caesura *Caesura) UnstageVoid(stage *StageStruct)

UnstageVoid removes caesura off the model stage

type Caesura_WOP 

type Caesura_WOP struct {
	// insertion point
	Name string
}

type Caesura_value 

type Caesura_value string
const (
	Caesura_valueNormal Caesura_value = "normal"

	Caesura_valueThick Caesura_value = "thick"

	Caesura_valueShort Caesura_value = "short"

	Caesura_valueCurved Caesura_value = "curved"

	Caesura_valueSingle Caesura_value = "single"

	Caesura_valueEmptyString Caesura_value = ""
)

func (Caesura_value) CodeValues 

func (caesura_value Caesura_value) CodeValues() (res []string)

func (Caesura_value) Codes 

func (caesura_value Caesura_value) Codes() (res []string)

func (*Caesura_value) FromCodeString 

func (caesura_value *Caesura_value) FromCodeString(input string) (err error)

func (*Caesura_value) FromString 

func (caesura_value *Caesura_value) FromString(input string) (err error)

func (*Caesura_value) ToCodeString 

func (caesura_value *Caesura_value) ToCodeString() (res string)

func (Caesura_value) ToString 

func (caesura_value Caesura_value) ToString() (res string)

Utility function for Caesura_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Cancel 

type Cancel struct {
	Name  string
	Value *Fifths `xml:",chardata" json:"-,"`

	Location *Cancel_location `xml:"location,attr,omitempty" json:"location,omitempty"`
}

func CopyBranchCancel 

func CopyBranchCancel(mapOrigCopy map[any]any, cancelFrom *Cancel) (cancelTo *Cancel)

func (*Cancel) Checkout 

func (cancel *Cancel) Checkout(stage *StageStruct) *Cancel

Checkout cancel to the back repo (if it is already staged)

func (*Cancel) Commit 

func (cancel *Cancel) Commit(stage *StageStruct) *Cancel

commit cancel to the back repo (if it is already staged)

func (*Cancel) CommitVoid 

func (cancel *Cancel) CommitVoid(stage *StageStruct)

func (*Cancel) CopyBasicFields 

func (from *Cancel) CopyBasicFields(to *Cancel)

func (*Cancel) GetName 

func (cancel *Cancel) GetName() (res string)

for satisfaction of GongStruct interface

func (*Cancel) Stage 

func (cancel *Cancel) Stage(stage *StageStruct) *Cancel

Stage puts cancel to the model stage

func (*Cancel) Unstage 

func (cancel *Cancel) Unstage(stage *StageStruct) *Cancel

Unstage removes cancel off the model stage

func (*Cancel) UnstageVoid 

func (cancel *Cancel) UnstageVoid(stage *StageStruct)

UnstageVoid removes cancel off the model stage

type Cancel_WOP 

type Cancel_WOP struct {
	// insertion point
	Name string
}

type Cancel_location 

type Cancel_location string
const (
	Cancel_locationLeft Cancel_location = "left"

	Cancel_locationRight Cancel_location = "right"

	Cancel_locationBefore_barline Cancel_location = "before-barline"
)

func (Cancel_location) CodeValues 

func (cancel_location Cancel_location) CodeValues() (res []string)

func (Cancel_location) Codes 

func (cancel_location Cancel_location) Codes() (res []string)

func (*Cancel_location) FromCodeString 

func (cancel_location *Cancel_location) FromCodeString(input string) (err error)

func (*Cancel_location) FromString 

func (cancel_location *Cancel_location) FromString(input string) (err error)

func (*Cancel_location) ToCodeString 

func (cancel_location *Cancel_location) ToCodeString() (res string)

func (Cancel_location) ToString 

func (cancel_location Cancel_location) ToString() (res string)

Utility function for Cancel_location if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Circular_arrow 

type Circular_arrow string
const (
	Circular_arrowClockwise Circular_arrow = "clockwise"

	Circular_arrowAnticlockwise Circular_arrow = "anticlockwise"
)

func (Circular_arrow) CodeValues 

func (circular_arrow Circular_arrow) CodeValues() (res []string)

func (Circular_arrow) Codes 

func (circular_arrow Circular_arrow) Codes() (res []string)

func (*Circular_arrow) FromCodeString 

func (circular_arrow *Circular_arrow) FromCodeString(input string) (err error)

func (*Circular_arrow) FromString 

func (circular_arrow *Circular_arrow) FromString(input string) (err error)

func (*Circular_arrow) ToCodeString 

func (circular_arrow *Circular_arrow) ToCodeString() (res string)

func (Circular_arrow) ToString 

func (circular_arrow Circular_arrow) ToString() (res string)

Utility function for Circular_arrow if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Clef 

type Clef struct {
	Name   string
	Number *Staff_number `xml:"number,attr,omitempty" json:"number,omitempty"`

	Additional *Yes_no `xml:"additional,attr,omitempty" json:"additional,omitempty"`

	Size *Symbol_size `xml:"size,attr,omitempty" json:"size,omitempty"`

	After_barline *Yes_no `xml:"after-barline,attr,omitempty" json:"after-barline,omitempty"`
}

func CopyBranchClef 

func CopyBranchClef(mapOrigCopy map[any]any, clefFrom *Clef) (clefTo *Clef)

func (*Clef) Checkout 

func (clef *Clef) Checkout(stage *StageStruct) *Clef

Checkout clef to the back repo (if it is already staged)

func (*Clef) Commit 

func (clef *Clef) Commit(stage *StageStruct) *Clef

commit clef to the back repo (if it is already staged)

func (*Clef) CommitVoid 

func (clef *Clef) CommitVoid(stage *StageStruct)

func (*Clef) CopyBasicFields 

func (from *Clef) CopyBasicFields(to *Clef)

func (*Clef) GetName 

func (clef *Clef) GetName() (res string)

for satisfaction of GongStruct interface

func (*Clef) Stage 

func (clef *Clef) Stage(stage *StageStruct) *Clef

Stage puts clef to the model stage

func (*Clef) Unstage 

func (clef *Clef) Unstage(stage *StageStruct) *Clef

Unstage removes clef off the model stage

func (*Clef) UnstageVoid 

func (clef *Clef) UnstageVoid(stage *StageStruct)

UnstageVoid removes clef off the model stage

type Clef_WOP 

type Clef_WOP struct {
	// insertion point
	Name string
}

type Clef_sign 

type Clef_sign string
const (
	Clef_signG Clef_sign = "G"

	Clef_signF Clef_sign = "F"

	Clef_signC Clef_sign = "C"

	Clef_signPercussion Clef_sign = "percussion"

	Clef_signTAB Clef_sign = "TAB"

	Clef_signJianpu Clef_sign = "jianpu"

	Clef_signNone Clef_sign = "none"
)

func (Clef_sign) CodeValues 

func (clef_sign Clef_sign) CodeValues() (res []string)

func (Clef_sign) Codes 

func (clef_sign Clef_sign) Codes() (res []string)

func (*Clef_sign) FromCodeString 

func (clef_sign *Clef_sign) FromCodeString(input string) (err error)

func (*Clef_sign) FromString 

func (clef_sign *Clef_sign) FromString(input string) (err error)

func (*Clef_sign) ToCodeString 

func (clef_sign *Clef_sign) ToCodeString() (res string)

func (Clef_sign) ToString 

func (clef_sign Clef_sign) ToString() (res string)

Utility function for Clef_sign if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Coda 

type Coda struct {
	Name  string
	Smufl *Smufl_coda_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchCoda 

func CopyBranchCoda(mapOrigCopy map[any]any, codaFrom *Coda) (codaTo *Coda)

func (*Coda) Checkout 

func (coda *Coda) Checkout(stage *StageStruct) *Coda

Checkout coda to the back repo (if it is already staged)

func (*Coda) Commit 

func (coda *Coda) Commit(stage *StageStruct) *Coda

commit coda to the back repo (if it is already staged)

func (*Coda) CommitVoid 

func (coda *Coda) CommitVoid(stage *StageStruct)

func (*Coda) CopyBasicFields 

func (from *Coda) CopyBasicFields(to *Coda)

func (*Coda) GetName 

func (coda *Coda) GetName() (res string)

for satisfaction of GongStruct interface

func (*Coda) Stage 

func (coda *Coda) Stage(stage *StageStruct) *Coda

Stage puts coda to the model stage

func (*Coda) Unstage 

func (coda *Coda) Unstage(stage *StageStruct) *Coda

Unstage removes coda off the model stage

func (*Coda) UnstageVoid 

func (coda *Coda) UnstageVoid(stage *StageStruct)

UnstageVoid removes coda off the model stage

type Coda_WOP 

type Coda_WOP struct {
	// insertion point
	Name string
}

type Color 

type Color string

func (Color) CodeValues 

func (color Color) CodeValues() (res []string)

func (Color) Codes 

func (color Color) Codes() (res []string)

func (*Color) FromCodeString 

func (color *Color) FromCodeString(input string) (err error)

func (*Color) FromString 

func (color *Color) FromString(input string) (err error)

func (*Color) ToCodeString 

func (color *Color) ToCodeString() (res string)

func (Color) ToString 

func (color Color) ToString() (res string)

Utility function for Color if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Comma_separated_text 

type Comma_separated_text string

func (Comma_separated_text) CodeValues 

func (comma_separated_text Comma_separated_text) CodeValues() (res []string)

func (Comma_separated_text) Codes 

func (comma_separated_text Comma_separated_text) Codes() (res []string)

func (*Comma_separated_text) FromCodeString 

func (comma_separated_text *Comma_separated_text) FromCodeString(input string) (err error)

func (*Comma_separated_text) FromString 

func (comma_separated_text *Comma_separated_text) FromString(input string) (err error)

func (*Comma_separated_text) ToCodeString 

func (comma_separated_text *Comma_separated_text) ToCodeString() (res string)

func (Comma_separated_text) ToString 

func (comma_separated_text Comma_separated_text) ToString() (res string)

Utility function for Comma_separated_text if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Credit 

type Credit struct {
	Name        string
	Credit_type []string `xml:"credit-type,omitempty" json:"credit-type,omitempty"`

	Link []*Link `xml:"link,omitempty" json:"link,omitempty"`

	Bookmark []*Bookmark `xml:"bookmark,omitempty" json:"bookmark,omitempty"`

	Credit_image *Image `xml:"credit-image,omitempty" json:"credit-image,omitempty"`

	Page *PositiveInteger `xml:"page,attr,omitempty" json:"page,omitempty"`
}

func CopyBranchCredit 

func CopyBranchCredit(mapOrigCopy map[any]any, creditFrom *Credit) (creditTo *Credit)

func (*Credit) Checkout 

func (credit *Credit) Checkout(stage *StageStruct) *Credit

Checkout credit to the back repo (if it is already staged)

func (*Credit) Commit 

func (credit *Credit) Commit(stage *StageStruct) *Credit

commit credit to the back repo (if it is already staged)

func (*Credit) CommitVoid 

func (credit *Credit) CommitVoid(stage *StageStruct)

func (*Credit) CopyBasicFields 

func (from *Credit) CopyBasicFields(to *Credit)

func (*Credit) GetName 

func (credit *Credit) GetName() (res string)

for satisfaction of GongStruct interface

func (*Credit) Stage 

func (credit *Credit) Stage(stage *StageStruct) *Credit

Stage puts credit to the model stage

func (*Credit) Unstage 

func (credit *Credit) Unstage(stage *StageStruct) *Credit

Unstage removes credit off the model stage

func (*Credit) UnstageVoid 

func (credit *Credit) UnstageVoid(stage *StageStruct)

UnstageVoid removes credit off the model stage

type Credit_WOP 

type Credit_WOP struct {
	// insertion point
	Name string
}

type Css_font_size 

type Css_font_size string
const (
	Css_font_sizeXx_small Css_font_size = "xx-small"

	Css_font_sizeX_small Css_font_size = "x-small"

	Css_font_sizeSmall Css_font_size = "small"

	Css_font_sizeMedium Css_font_size = "medium"

	Css_font_sizeLarge Css_font_size = "large"

	Css_font_sizeX_large Css_font_size = "x-large"

	Css_font_sizeXx_large Css_font_size = "xx-large"
)

func (Css_font_size) CodeValues 

func (css_font_size Css_font_size) CodeValues() (res []string)

func (Css_font_size) Codes 

func (css_font_size Css_font_size) Codes() (res []string)

func (*Css_font_size) FromCodeString 

func (css_font_size *Css_font_size) FromCodeString(input string) (err error)

func (*Css_font_size) FromString 

func (css_font_size *Css_font_size) FromString(input string) (err error)

func (*Css_font_size) ToCodeString 

func (css_font_size *Css_font_size) ToCodeString() (res string)

func (Css_font_size) ToString 

func (css_font_size Css_font_size) ToString() (res string)

Utility function for Css_font_size if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Dashes 

type Dashes struct {
	Name string
	Type *Start_stop_continue `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchDashes 

func CopyBranchDashes(mapOrigCopy map[any]any, dashesFrom *Dashes) (dashesTo *Dashes)

func (*Dashes) Checkout 

func (dashes *Dashes) Checkout(stage *StageStruct) *Dashes

Checkout dashes to the back repo (if it is already staged)

func (*Dashes) Commit 

func (dashes *Dashes) Commit(stage *StageStruct) *Dashes

commit dashes to the back repo (if it is already staged)

func (*Dashes) CommitVoid 

func (dashes *Dashes) CommitVoid(stage *StageStruct)

func (*Dashes) CopyBasicFields 

func (from *Dashes) CopyBasicFields(to *Dashes)

func (*Dashes) GetName 

func (dashes *Dashes) GetName() (res string)

for satisfaction of GongStruct interface

func (*Dashes) Stage 

func (dashes *Dashes) Stage(stage *StageStruct) *Dashes

Stage puts dashes to the model stage

func (*Dashes) Unstage 

func (dashes *Dashes) Unstage(stage *StageStruct) *Dashes

Unstage removes dashes off the model stage

func (*Dashes) UnstageVoid 

func (dashes *Dashes) UnstageVoid(stage *StageStruct)

UnstageVoid removes dashes off the model stage

type Dashes_WOP 

type Dashes_WOP struct {
	// insertion point
	Name string
}

type Defaults 

type Defaults struct {
	Name    string
	Scaling *Scaling `xml:"scaling,omitempty" json:"scaling,omitempty"`

	// The presence of a concert-score element indicates that a score
	// is displayed in concert pitch. It is used for scores that contain parts for
	// transposing instruments. A document with a concert-score element may not
	// contain any transpose elements that have non-zero values for either the
	// diatonic or chromatic elements. Concert scores may include octave
	// transpositions, so transpose elements with a double element or a non-zero
	// octave-change element value are permitted.
	Concert_score *Empty `xml:"concert-score,omitempty" json:"concert-score,omitempty"`

	Appearance *Appearance `xml:"appearance,omitempty" json:"appearance,omitempty"`

	Music_font *Empty_font `xml:"music-font,omitempty" json:"music-font,omitempty"`

	Word_font *Empty_font `xml:"word-font,omitempty" json:"word-font,omitempty"`

	Lyric_font []*Lyric_font `xml:"lyric-font,omitempty" json:"lyric-font,omitempty"`

	Lyric_language []*Lyric_language `xml:"lyric-language,omitempty" json:"lyric-language,omitempty"`
}

func CopyBranchDefaults 

func CopyBranchDefaults(mapOrigCopy map[any]any, defaultsFrom *Defaults) (defaultsTo *Defaults)

func (*Defaults) Checkout 

func (defaults *Defaults) Checkout(stage *StageStruct) *Defaults

Checkout defaults to the back repo (if it is already staged)

func (*Defaults) Commit 

func (defaults *Defaults) Commit(stage *StageStruct) *Defaults

commit defaults to the back repo (if it is already staged)

func (*Defaults) CommitVoid 

func (defaults *Defaults) CommitVoid(stage *StageStruct)

func (*Defaults) CopyBasicFields 

func (from *Defaults) CopyBasicFields(to *Defaults)

func (*Defaults) GetName 

func (defaults *Defaults) GetName() (res string)

for satisfaction of GongStruct interface

func (*Defaults) Stage 

func (defaults *Defaults) Stage(stage *StageStruct) *Defaults

Stage puts defaults to the model stage

func (*Defaults) Unstage 

func (defaults *Defaults) Unstage(stage *StageStruct) *Defaults

Unstage removes defaults off the model stage

func (*Defaults) UnstageVoid 

func (defaults *Defaults) UnstageVoid(stage *StageStruct)

UnstageVoid removes defaults off the model stage

type Defaults_WOP 

type Defaults_WOP struct {
	// insertion point
	Name string
}

type Degree 

type Degree struct {
	Name         string
	Degree_value *Degree_value `xml:"degree-value,omitempty" json:"degree-value,omitempty"`

	Degree_alter *Degree_alter `xml:"degree-alter,omitempty" json:"degree-alter,omitempty"`

	Degree_type *Degree_type `xml:"degree-type,omitempty" json:"degree-type,omitempty"`
}

func CopyBranchDegree 

func CopyBranchDegree(mapOrigCopy map[any]any, degreeFrom *Degree) (degreeTo *Degree)

func (*Degree) Checkout 

func (degree *Degree) Checkout(stage *StageStruct) *Degree

Checkout degree to the back repo (if it is already staged)

func (*Degree) Commit 

func (degree *Degree) Commit(stage *StageStruct) *Degree

commit degree to the back repo (if it is already staged)

func (*Degree) CommitVoid 

func (degree *Degree) CommitVoid(stage *StageStruct)

func (*Degree) CopyBasicFields 

func (from *Degree) CopyBasicFields(to *Degree)

func (*Degree) GetName 

func (degree *Degree) GetName() (res string)

for satisfaction of GongStruct interface

func (*Degree) Stage 

func (degree *Degree) Stage(stage *StageStruct) *Degree

Stage puts degree to the model stage

func (*Degree) Unstage 

func (degree *Degree) Unstage(stage *StageStruct) *Degree

Unstage removes degree off the model stage

func (*Degree) UnstageVoid 

func (degree *Degree) UnstageVoid(stage *StageStruct)

UnstageVoid removes degree off the model stage

type Degree_WOP 

type Degree_WOP struct {
	// insertion point
	Name string
}

type Degree_alter 

type Degree_alter struct {
	Name  string
	Value *Semitones `xml:",chardata" json:"-,"`

	Plus_minus *Yes_no `xml:"plus-minus,attr,omitempty" json:"plus-minus,omitempty"`
}

func CopyBranchDegree_alter 

func CopyBranchDegree_alter(mapOrigCopy map[any]any, degree_alterFrom *Degree_alter) (degree_alterTo *Degree_alter)

func (*Degree_alter) Checkout 

func (degree_alter *Degree_alter) Checkout(stage *StageStruct) *Degree_alter

Checkout degree_alter to the back repo (if it is already staged)

func (*Degree_alter) Commit 

func (degree_alter *Degree_alter) Commit(stage *StageStruct) *Degree_alter

commit degree_alter to the back repo (if it is already staged)

func (*Degree_alter) CommitVoid 

func (degree_alter *Degree_alter) CommitVoid(stage *StageStruct)

func (*Degree_alter) CopyBasicFields 

func (from *Degree_alter) CopyBasicFields(to *Degree_alter)

func (*Degree_alter) GetName 

func (degree_alter *Degree_alter) GetName() (res string)

for satisfaction of GongStruct interface

func (*Degree_alter) Stage 

func (degree_alter *Degree_alter) Stage(stage *StageStruct) *Degree_alter

Stage puts degree_alter to the model stage

func (*Degree_alter) Unstage 

func (degree_alter *Degree_alter) Unstage(stage *StageStruct) *Degree_alter

Unstage removes degree_alter off the model stage

func (*Degree_alter) UnstageVoid 

func (degree_alter *Degree_alter) UnstageVoid(stage *StageStruct)

UnstageVoid removes degree_alter off the model stage

type Degree_alter_WOP 

type Degree_alter_WOP struct {
	// insertion point
	Name string
}

type Degree_symbol_value 

type Degree_symbol_value string
const (
	Degree_symbol_valueMajor Degree_symbol_value = "major"

	Degree_symbol_valueMinor Degree_symbol_value = "minor"

	Degree_symbol_valueAugmented Degree_symbol_value = "augmented"

	Degree_symbol_valueDiminished Degree_symbol_value = "diminished"

	Degree_symbol_valueHalf_diminished Degree_symbol_value = "half-diminished"
)

func (Degree_symbol_value) CodeValues 

func (degree_symbol_value Degree_symbol_value) CodeValues() (res []string)

func (Degree_symbol_value) Codes 

func (degree_symbol_value Degree_symbol_value) Codes() (res []string)

func (*Degree_symbol_value) FromCodeString 

func (degree_symbol_value *Degree_symbol_value) FromCodeString(input string) (err error)

func (*Degree_symbol_value) FromString 

func (degree_symbol_value *Degree_symbol_value) FromString(input string) (err error)

func (*Degree_symbol_value) ToCodeString 

func (degree_symbol_value *Degree_symbol_value) ToCodeString() (res string)

func (Degree_symbol_value) ToString 

func (degree_symbol_value Degree_symbol_value) ToString() (res string)

Utility function for Degree_symbol_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Degree_type 

type Degree_type struct {
	Name  string
	Value *Degree_type_value `xml:",chardata" json:"-,"`

	Text string `xml:"text,attr,omitempty" json:"text,omitempty"`
}

func CopyBranchDegree_type 

func CopyBranchDegree_type(mapOrigCopy map[any]any, degree_typeFrom *Degree_type) (degree_typeTo *Degree_type)

func (*Degree_type) Checkout 

func (degree_type *Degree_type) Checkout(stage *StageStruct) *Degree_type

Checkout degree_type to the back repo (if it is already staged)

func (*Degree_type) Commit 

func (degree_type *Degree_type) Commit(stage *StageStruct) *Degree_type

commit degree_type to the back repo (if it is already staged)

func (*Degree_type) CommitVoid 

func (degree_type *Degree_type) CommitVoid(stage *StageStruct)

func (*Degree_type) CopyBasicFields 

func (from *Degree_type) CopyBasicFields(to *Degree_type)

func (*Degree_type) GetName 

func (degree_type *Degree_type) GetName() (res string)

for satisfaction of GongStruct interface

func (*Degree_type) Stage 

func (degree_type *Degree_type) Stage(stage *StageStruct) *Degree_type

Stage puts degree_type to the model stage

func (*Degree_type) Unstage 

func (degree_type *Degree_type) Unstage(stage *StageStruct) *Degree_type

Unstage removes degree_type off the model stage

func (*Degree_type) UnstageVoid 

func (degree_type *Degree_type) UnstageVoid(stage *StageStruct)

UnstageVoid removes degree_type off the model stage

type Degree_type_WOP 

type Degree_type_WOP struct {
	// insertion point
	Name string
	Text string
}

type Degree_type_value 

type Degree_type_value string
const (
	Degree_type_valueAdd Degree_type_value = "add"

	Degree_type_valueAlter Degree_type_value = "alter"

	Degree_type_valueSubtract Degree_type_value = "subtract"
)

func (Degree_type_value) CodeValues 

func (degree_type_value Degree_type_value) CodeValues() (res []string)

func (Degree_type_value) Codes 

func (degree_type_value Degree_type_value) Codes() (res []string)

func (*Degree_type_value) FromCodeString 

func (degree_type_value *Degree_type_value) FromCodeString(input string) (err error)

func (*Degree_type_value) FromString 

func (degree_type_value *Degree_type_value) FromString(input string) (err error)

func (*Degree_type_value) ToCodeString 

func (degree_type_value *Degree_type_value) ToCodeString() (res string)

func (Degree_type_value) ToString 

func (degree_type_value Degree_type_value) ToString() (res string)

Utility function for Degree_type_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Degree_value 

type Degree_value struct {
	Name  string
	Value *PositiveInteger `xml:",chardata" json:"-,"`

	Symbol *Degree_symbol_value `xml:"symbol,attr,omitempty" json:"symbol,omitempty"`

	Text string `xml:"text,attr,omitempty" json:"text,omitempty"`
}

func CopyBranchDegree_value 

func CopyBranchDegree_value(mapOrigCopy map[any]any, degree_valueFrom *Degree_value) (degree_valueTo *Degree_value)

func (*Degree_value) Checkout 

func (degree_value *Degree_value) Checkout(stage *StageStruct) *Degree_value

Checkout degree_value to the back repo (if it is already staged)

func (*Degree_value) Commit 

func (degree_value *Degree_value) Commit(stage *StageStruct) *Degree_value

commit degree_value to the back repo (if it is already staged)

func (*Degree_value) CommitVoid 

func (degree_value *Degree_value) CommitVoid(stage *StageStruct)

func (*Degree_value) CopyBasicFields 

func (from *Degree_value) CopyBasicFields(to *Degree_value)

func (*Degree_value) GetName 

func (degree_value *Degree_value) GetName() (res string)

for satisfaction of GongStruct interface

func (*Degree_value) Stage 

func (degree_value *Degree_value) Stage(stage *StageStruct) *Degree_value

Stage puts degree_value to the model stage

func (*Degree_value) Unstage 

func (degree_value *Degree_value) Unstage(stage *StageStruct) *Degree_value

Unstage removes degree_value off the model stage

func (*Degree_value) UnstageVoid 

func (degree_value *Degree_value) UnstageVoid(stage *StageStruct)

UnstageVoid removes degree_value off the model stage

type Degree_value_WOP 

type Degree_value_WOP struct {
	// insertion point
	Name string
	Text string
}

type Direction 

type Direction struct {
	Name           string
	Direction_type []*Direction_type `xml:"direction-type,omitempty" json:"direction-type,omitempty"`

	Offset *Offset `xml:"offset,omitempty" json:"offset,omitempty"`

	Sound *Sound `xml:"sound,omitempty" json:"sound,omitempty"`

	Listening *Listening `xml:"listening,omitempty" json:"listening,omitempty"`
}

func CopyBranchDirection 

func CopyBranchDirection(mapOrigCopy map[any]any, directionFrom *Direction) (directionTo *Direction)

func (*Direction) Checkout 

func (direction *Direction) Checkout(stage *StageStruct) *Direction

Checkout direction to the back repo (if it is already staged)

func (*Direction) Commit 

func (direction *Direction) Commit(stage *StageStruct) *Direction

commit direction to the back repo (if it is already staged)

func (*Direction) CommitVoid 

func (direction *Direction) CommitVoid(stage *StageStruct)

func (*Direction) CopyBasicFields 

func (from *Direction) CopyBasicFields(to *Direction)

func (*Direction) GetName 

func (direction *Direction) GetName() (res string)

for satisfaction of GongStruct interface

func (*Direction) Stage 

func (direction *Direction) Stage(stage *StageStruct) *Direction

Stage puts direction to the model stage

func (*Direction) Unstage 

func (direction *Direction) Unstage(stage *StageStruct) *Direction

Unstage removes direction off the model stage

func (*Direction) UnstageVoid 

func (direction *Direction) UnstageVoid(stage *StageStruct)

UnstageVoid removes direction off the model stage

type Direction_WOP 

type Direction_WOP struct {
	// insertion point
	Name string
}

type Direction_type 

type Direction_type struct {
	Name string

	// The rehearsal element specifies letters, numbers, and section
	// names that are notated in the score for reference during rehearsal. The
	// enclosure is square if not specified. The language is Italian ("it") if not
	// specified. Left justification is used if not specified.
	Rehearsal []*Formatted_text_id `xml:"rehearsal,omitempty" json:"rehearsal,omitempty"`

	Segno []*Segno `xml:"segno,omitempty" json:"segno,omitempty"`

	Coda []*Coda `xml:"coda,omitempty" json:"coda,omitempty"`

	Wedge *Wedge `xml:"wedge,omitempty" json:"wedge,omitempty"`

	Dynamics []*Dynamics `xml:"dynamics,omitempty" json:"dynamics,omitempty"`

	Dashes *Dashes `xml:"dashes,omitempty" json:"dashes,omitempty"`

	Bracket *Bracket `xml:"bracket,omitempty" json:"bracket,omitempty"`

	Pedal *Pedal `xml:"pedal,omitempty" json:"pedal,omitempty"`

	Metronome *Metronome `xml:"metronome,omitempty" json:"metronome,omitempty"`

	Octave_shift *Octave_shift `xml:"octave-shift,omitempty" json:"octave-shift,omitempty"`

	Harp_pedals *Harp_pedals `xml:"harp-pedals,omitempty" json:"harp-pedals,omitempty"`

	// The damp element specifies a harp damping mark.
	Damp *Empty_print_style_align_id `xml:"damp,omitempty" json:"damp,omitempty"`

	// The damp-all element specifies a harp damping mark for all
	// strings.
	Damp_all *Empty_print_style_align_id `xml:"damp-all,omitempty" json:"damp-all,omitempty"`

	// The eyeglasses element represents the eyeglasses symbol,
	// common in commercial music.
	Eyeglasses *Empty_print_style_align_id `xml:"eyeglasses,omitempty" json:"eyeglasses,omitempty"`

	String_mute *String_mute `xml:"string-mute,omitempty" json:"string-mute,omitempty"`

	Scordatura *Scordatura `xml:"scordatura,omitempty" json:"scordatura,omitempty"`

	Image *Image `xml:"image,omitempty" json:"image,omitempty"`

	Principal_voice *Principal_voice `xml:"principal-voice,omitempty" json:"principal-voice,omitempty"`

	Percussion []*Percussion `xml:"percussion,omitempty" json:"percussion,omitempty"`

	Accordion_registration *Accordion_registration `xml:"accordion-registration,omitempty" json:"accordion-registration,omitempty"`

	Staff_divide *Staff_divide `xml:"staff-divide,omitempty" json:"staff-divide,omitempty"`

	Other_direction *Other_direction `xml:"other-direction,omitempty" json:"other-direction,omitempty"`
}

func CopyBranchDirection_type 

func CopyBranchDirection_type(mapOrigCopy map[any]any, direction_typeFrom *Direction_type) (direction_typeTo *Direction_type)

func (*Direction_type) Checkout 

func (direction_type *Direction_type) Checkout(stage *StageStruct) *Direction_type

Checkout direction_type to the back repo (if it is already staged)

func (*Direction_type) Commit 

func (direction_type *Direction_type) Commit(stage *StageStruct) *Direction_type

commit direction_type to the back repo (if it is already staged)

func (*Direction_type) CommitVoid 

func (direction_type *Direction_type) CommitVoid(stage *StageStruct)

func (*Direction_type) CopyBasicFields 

func (from *Direction_type) CopyBasicFields(to *Direction_type)

func (*Direction_type) GetName 

func (direction_type *Direction_type) GetName() (res string)

for satisfaction of GongStruct interface

func (*Direction_type) Stage 

func (direction_type *Direction_type) Stage(stage *StageStruct) *Direction_type

Stage puts direction_type to the model stage

func (*Direction_type) Unstage 

func (direction_type *Direction_type) Unstage(stage *StageStruct) *Direction_type

Unstage removes direction_type off the model stage

func (*Direction_type) UnstageVoid 

func (direction_type *Direction_type) UnstageVoid(stage *StageStruct)

UnstageVoid removes direction_type off the model stage

type Direction_type_WOP 

type Direction_type_WOP struct {
	// insertion point
	Name string
}

type Distance 

type Distance struct {
	Name  string
	Value *Tenths `xml:",chardata" json:"-,"`

	Type *Distance_type `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchDistance 

func CopyBranchDistance(mapOrigCopy map[any]any, distanceFrom *Distance) (distanceTo *Distance)

func (*Distance) Checkout 

func (distance *Distance) Checkout(stage *StageStruct) *Distance

Checkout distance to the back repo (if it is already staged)

func (*Distance) Commit 

func (distance *Distance) Commit(stage *StageStruct) *Distance

commit distance to the back repo (if it is already staged)

func (*Distance) CommitVoid 

func (distance *Distance) CommitVoid(stage *StageStruct)

func (*Distance) CopyBasicFields 

func (from *Distance) CopyBasicFields(to *Distance)

func (*Distance) GetName 

func (distance *Distance) GetName() (res string)

for satisfaction of GongStruct interface

func (*Distance) Stage 

func (distance *Distance) Stage(stage *StageStruct) *Distance

Stage puts distance to the model stage

func (*Distance) Unstage 

func (distance *Distance) Unstage(stage *StageStruct) *Distance

Unstage removes distance off the model stage

func (*Distance) UnstageVoid 

func (distance *Distance) UnstageVoid(stage *StageStruct)

UnstageVoid removes distance off the model stage

type Distance_WOP 

type Distance_WOP struct {
	// insertion point
	Name string
}

type Distance_type 

type Distance_type string

func (Distance_type) CodeValues 

func (distance_type Distance_type) CodeValues() (res []string)

func (Distance_type) Codes 

func (distance_type Distance_type) Codes() (res []string)

func (*Distance_type) FromCodeString 

func (distance_type *Distance_type) FromCodeString(input string) (err error)

func (*Distance_type) FromString 

func (distance_type *Distance_type) FromString(input string) (err error)

func (*Distance_type) ToCodeString 

func (distance_type *Distance_type) ToCodeString() (res string)

func (Distance_type) ToString 

func (distance_type Distance_type) ToString() (res string)

Utility function for Distance_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Divisions 

type Divisions float64

type Double 

type Double struct {
	Name  string
	Above *Yes_no `xml:"above,attr,omitempty" json:"above,omitempty"`
}

func CopyBranchDouble 

func CopyBranchDouble(mapOrigCopy map[any]any, doubleFrom *Double) (doubleTo *Double)

func (*Double) Checkout 

func (double *Double) Checkout(stage *StageStruct) *Double

Checkout double to the back repo (if it is already staged)

func (*Double) Commit 

func (double *Double) Commit(stage *StageStruct) *Double

commit double to the back repo (if it is already staged)

func (*Double) CommitVoid 

func (double *Double) CommitVoid(stage *StageStruct)

func (*Double) CopyBasicFields 

func (from *Double) CopyBasicFields(to *Double)

func (*Double) GetName 

func (double *Double) GetName() (res string)

for satisfaction of GongStruct interface

func (*Double) Stage 

func (double *Double) Stage(stage *StageStruct) *Double

Stage puts double to the model stage

func (*Double) Unstage 

func (double *Double) Unstage(stage *StageStruct) *Double

Unstage removes double off the model stage

func (*Double) UnstageVoid 

func (double *Double) UnstageVoid(stage *StageStruct)

UnstageVoid removes double off the model stage

type Double_WOP 

type Double_WOP struct {
	// insertion point
	Name string
}

type Dynamics 

type Dynamics struct {
	Name string
	P    *Empty `xml:"p,omitempty" json:"p,omitempty"`

	Pp *Empty `xml:"pp,omitempty" json:"pp,omitempty"`

	Ppp *Empty `xml:"ppp,omitempty" json:"ppp,omitempty"`

	Pppp *Empty `xml:"pppp,omitempty" json:"pppp,omitempty"`

	Ppppp *Empty `xml:"ppppp,omitempty" json:"ppppp,omitempty"`

	Pppppp *Empty `xml:"pppppp,omitempty" json:"pppppp,omitempty"`

	F *Empty `xml:"f,omitempty" json:"f,omitempty"`

	Ff *Empty `xml:"ff,omitempty" json:"ff,omitempty"`

	Fff *Empty `xml:"fff,omitempty" json:"fff,omitempty"`

	Ffff *Empty `xml:"ffff,omitempty" json:"ffff,omitempty"`

	Fffff *Empty `xml:"fffff,omitempty" json:"fffff,omitempty"`

	Ffffff *Empty `xml:"ffffff,omitempty" json:"ffffff,omitempty"`

	Mp *Empty `xml:"mp,omitempty" json:"mp,omitempty"`

	Mf *Empty `xml:"mf,omitempty" json:"mf,omitempty"`

	Sf *Empty `xml:"sf,omitempty" json:"sf,omitempty"`

	Sfp *Empty `xml:"sfp,omitempty" json:"sfp,omitempty"`

	Sfpp *Empty `xml:"sfpp,omitempty" json:"sfpp,omitempty"`

	Fp *Empty `xml:"fp,omitempty" json:"fp,omitempty"`

	Rf *Empty `xml:"rf,omitempty" json:"rf,omitempty"`

	Rfz *Empty `xml:"rfz,omitempty" json:"rfz,omitempty"`

	Sfz *Empty `xml:"sfz,omitempty" json:"sfz,omitempty"`

	Sffz *Empty `xml:"sffz,omitempty" json:"sffz,omitempty"`

	Fz *Empty `xml:"fz,omitempty" json:"fz,omitempty"`

	N *Empty `xml:"n,omitempty" json:"n,omitempty"`

	Pf *Empty `xml:"pf,omitempty" json:"pf,omitempty"`

	Sfzp *Empty `xml:"sfzp,omitempty" json:"sfzp,omitempty"`

	Other_dynamics *Other_text `xml:"other-dynamics,omitempty" json:"other-dynamics,omitempty"`
}

func CopyBranchDynamics 

func CopyBranchDynamics(mapOrigCopy map[any]any, dynamicsFrom *Dynamics) (dynamicsTo *Dynamics)

func (*Dynamics) Checkout 

func (dynamics *Dynamics) Checkout(stage *StageStruct) *Dynamics

Checkout dynamics to the back repo (if it is already staged)

func (*Dynamics) Commit 

func (dynamics *Dynamics) Commit(stage *StageStruct) *Dynamics

commit dynamics to the back repo (if it is already staged)

func (*Dynamics) CommitVoid 

func (dynamics *Dynamics) CommitVoid(stage *StageStruct)

func (*Dynamics) CopyBasicFields 

func (from *Dynamics) CopyBasicFields(to *Dynamics)

func (*Dynamics) GetName 

func (dynamics *Dynamics) GetName() (res string)

for satisfaction of GongStruct interface

func (*Dynamics) Stage 

func (dynamics *Dynamics) Stage(stage *StageStruct) *Dynamics

Stage puts dynamics to the model stage

func (*Dynamics) Unstage 

func (dynamics *Dynamics) Unstage(stage *StageStruct) *Dynamics

Unstage removes dynamics off the model stage

func (*Dynamics) UnstageVoid 

func (dynamics *Dynamics) UnstageVoid(stage *StageStruct)

UnstageVoid removes dynamics off the model stage

type Dynamics_WOP 

type Dynamics_WOP struct {
	// insertion point
	Name string
}

type Effect 

type Effect struct {
	Name  string
	Value *Effect_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_pictogram_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchEffect 

func CopyBranchEffect(mapOrigCopy map[any]any, effectFrom *Effect) (effectTo *Effect)

func (*Effect) Checkout 

func (effect *Effect) Checkout(stage *StageStruct) *Effect

Checkout effect to the back repo (if it is already staged)

func (*Effect) Commit 

func (effect *Effect) Commit(stage *StageStruct) *Effect

commit effect to the back repo (if it is already staged)

func (*Effect) CommitVoid 

func (effect *Effect) CommitVoid(stage *StageStruct)

func (*Effect) CopyBasicFields 

func (from *Effect) CopyBasicFields(to *Effect)

func (*Effect) GetName 

func (effect *Effect) GetName() (res string)

for satisfaction of GongStruct interface

func (*Effect) Stage 

func (effect *Effect) Stage(stage *StageStruct) *Effect

Stage puts effect to the model stage

func (*Effect) Unstage 

func (effect *Effect) Unstage(stage *StageStruct) *Effect

Unstage removes effect off the model stage

func (*Effect) UnstageVoid 

func (effect *Effect) UnstageVoid(stage *StageStruct)

UnstageVoid removes effect off the model stage

type Effect_WOP 

type Effect_WOP struct {
	// insertion point
	Name string
}

type Effect_value 

type Effect_value string
const (
	Effect_valueAnvil Effect_value = "anvil"

	Effect_valueAutohorn Effect_value = "auto horn"

	Effect_valueBirdwhistle Effect_value = "bird whistle"

	Effect_valueCannon Effect_value = "cannon"

	Effect_valueDuckcall Effect_value = "duck call"

	Effect_valueGunshot Effect_value = "gun shot"

	Effect_valueKlaxonhorn Effect_value = "klaxon horn"

	Effect_valueLionsroar Effect_value = "lions roar"

	Effect_valueLotusflute Effect_value = "lotus flute"

	Effect_valueMegaphone Effect_value = "megaphone"

	Effect_valuePolicewhistle Effect_value = "police whistle"

	Effect_valueSiren Effect_value = "siren"

	Effect_valueSlidewhistle Effect_value = "slide whistle"

	Effect_valueThundersheet Effect_value = "thunder sheet"

	Effect_valueWindmachine Effect_value = "wind machine"

	Effect_valueWindwhistle Effect_value = "wind whistle"
)

func (Effect_value) CodeValues 

func (effect_value Effect_value) CodeValues() (res []string)

func (Effect_value) Codes 

func (effect_value Effect_value) Codes() (res []string)

func (*Effect_value) FromCodeString 

func (effect_value *Effect_value) FromCodeString(input string) (err error)

func (*Effect_value) FromString 

func (effect_value *Effect_value) FromString(input string) (err error)

func (*Effect_value) ToCodeString 

func (effect_value *Effect_value) ToCodeString() (res string)

func (Effect_value) ToString 

func (effect_value Effect_value) ToString() (res string)

Utility function for Effect_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Elision 

type Elision struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Smufl *Smufl_lyrics_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchElision 

func CopyBranchElision(mapOrigCopy map[any]any, elisionFrom *Elision) (elisionTo *Elision)

func (*Elision) Checkout 

func (elision *Elision) Checkout(stage *StageStruct) *Elision

Checkout elision to the back repo (if it is already staged)

func (*Elision) Commit 

func (elision *Elision) Commit(stage *StageStruct) *Elision

commit elision to the back repo (if it is already staged)

func (*Elision) CommitVoid 

func (elision *Elision) CommitVoid(stage *StageStruct)

func (*Elision) CopyBasicFields 

func (from *Elision) CopyBasicFields(to *Elision)

func (*Elision) GetName 

func (elision *Elision) GetName() (res string)

for satisfaction of GongStruct interface

func (*Elision) Stage 

func (elision *Elision) Stage(stage *StageStruct) *Elision

Stage puts elision to the model stage

func (*Elision) Unstage 

func (elision *Elision) Unstage(stage *StageStruct) *Elision

Unstage removes elision off the model stage

func (*Elision) UnstageVoid 

func (elision *Elision) UnstageVoid(stage *StageStruct)

UnstageVoid removes elision off the model stage

type Elision_WOP 

type Elision_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Empty 

type Empty struct {
	Name string
}

func CopyBranchEmpty 

func CopyBranchEmpty(mapOrigCopy map[any]any, emptyFrom *Empty) (emptyTo *Empty)

func (*Empty) Checkout 

func (empty *Empty) Checkout(stage *StageStruct) *Empty

Checkout empty to the back repo (if it is already staged)

func (*Empty) Commit 

func (empty *Empty) Commit(stage *StageStruct) *Empty

commit empty to the back repo (if it is already staged)

func (*Empty) CommitVoid 

func (empty *Empty) CommitVoid(stage *StageStruct)

func (*Empty) CopyBasicFields 

func (from *Empty) CopyBasicFields(to *Empty)

func (*Empty) GetName 

func (empty *Empty) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty) Stage 

func (empty *Empty) Stage(stage *StageStruct) *Empty

Stage puts empty to the model stage

func (*Empty) Unstage 

func (empty *Empty) Unstage(stage *StageStruct) *Empty

Unstage removes empty off the model stage

func (*Empty) UnstageVoid 

func (empty *Empty) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty off the model stage

type Empty_WOP 

type Empty_WOP struct {
	// insertion point
	Name string
}

type Empty_font 

type Empty_font struct {
	Name string
}

func CopyBranchEmpty_font 

func CopyBranchEmpty_font(mapOrigCopy map[any]any, empty_fontFrom *Empty_font) (empty_fontTo *Empty_font)

func (*Empty_font) Checkout 

func (empty_font *Empty_font) Checkout(stage *StageStruct) *Empty_font

Checkout empty_font to the back repo (if it is already staged)

func (*Empty_font) Commit 

func (empty_font *Empty_font) Commit(stage *StageStruct) *Empty_font

commit empty_font to the back repo (if it is already staged)

func (*Empty_font) CommitVoid 

func (empty_font *Empty_font) CommitVoid(stage *StageStruct)

func (*Empty_font) CopyBasicFields 

func (from *Empty_font) CopyBasicFields(to *Empty_font)

func (*Empty_font) GetName 

func (empty_font *Empty_font) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_font) Stage 

func (empty_font *Empty_font) Stage(stage *StageStruct) *Empty_font

Stage puts empty_font to the model stage

func (*Empty_font) Unstage 

func (empty_font *Empty_font) Unstage(stage *StageStruct) *Empty_font

Unstage removes empty_font off the model stage

func (*Empty_font) UnstageVoid 

func (empty_font *Empty_font) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_font off the model stage

type Empty_font_WOP 

type Empty_font_WOP struct {
	// insertion point
	Name string
}

type Empty_line 

type Empty_line struct {
	Name string
}

func CopyBranchEmpty_line 

func CopyBranchEmpty_line(mapOrigCopy map[any]any, empty_lineFrom *Empty_line) (empty_lineTo *Empty_line)

func (*Empty_line) Checkout 

func (empty_line *Empty_line) Checkout(stage *StageStruct) *Empty_line

Checkout empty_line to the back repo (if it is already staged)

func (*Empty_line) Commit 

func (empty_line *Empty_line) Commit(stage *StageStruct) *Empty_line

commit empty_line to the back repo (if it is already staged)

func (*Empty_line) CommitVoid 

func (empty_line *Empty_line) CommitVoid(stage *StageStruct)

func (*Empty_line) CopyBasicFields 

func (from *Empty_line) CopyBasicFields(to *Empty_line)

func (*Empty_line) GetName 

func (empty_line *Empty_line) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_line) Stage 

func (empty_line *Empty_line) Stage(stage *StageStruct) *Empty_line

Stage puts empty_line to the model stage

func (*Empty_line) Unstage 

func (empty_line *Empty_line) Unstage(stage *StageStruct) *Empty_line

Unstage removes empty_line off the model stage

func (*Empty_line) UnstageVoid 

func (empty_line *Empty_line) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_line off the model stage

type Empty_line_WOP 

type Empty_line_WOP struct {
	// insertion point
	Name string
}

type Empty_placement 

type Empty_placement struct {
	Name string
}

func CopyBranchEmpty_placement 

func CopyBranchEmpty_placement(mapOrigCopy map[any]any, empty_placementFrom *Empty_placement) (empty_placementTo *Empty_placement)

func (*Empty_placement) Checkout 

func (empty_placement *Empty_placement) Checkout(stage *StageStruct) *Empty_placement

Checkout empty_placement to the back repo (if it is already staged)

func (*Empty_placement) Commit 

func (empty_placement *Empty_placement) Commit(stage *StageStruct) *Empty_placement

commit empty_placement to the back repo (if it is already staged)

func (*Empty_placement) CommitVoid 

func (empty_placement *Empty_placement) CommitVoid(stage *StageStruct)

func (*Empty_placement) CopyBasicFields 

func (from *Empty_placement) CopyBasicFields(to *Empty_placement)

func (*Empty_placement) GetName 

func (empty_placement *Empty_placement) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_placement) Stage 

func (empty_placement *Empty_placement) Stage(stage *StageStruct) *Empty_placement

Stage puts empty_placement to the model stage

func (*Empty_placement) Unstage 

func (empty_placement *Empty_placement) Unstage(stage *StageStruct) *Empty_placement

Unstage removes empty_placement off the model stage

func (*Empty_placement) UnstageVoid 

func (empty_placement *Empty_placement) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_placement off the model stage

type Empty_placement_WOP 

type Empty_placement_WOP struct {
	// insertion point
	Name string
}

type Empty_placement_smufl 

type Empty_placement_smufl struct {
	Name string
}

func CopyBranchEmpty_placement_smufl 

func CopyBranchEmpty_placement_smufl(mapOrigCopy map[any]any, empty_placement_smuflFrom *Empty_placement_smufl) (empty_placement_smuflTo *Empty_placement_smufl)

func (*Empty_placement_smufl) Checkout 

func (empty_placement_smufl *Empty_placement_smufl) Checkout(stage *StageStruct) *Empty_placement_smufl

Checkout empty_placement_smufl to the back repo (if it is already staged)

func (*Empty_placement_smufl) Commit 

func (empty_placement_smufl *Empty_placement_smufl) Commit(stage *StageStruct) *Empty_placement_smufl

commit empty_placement_smufl to the back repo (if it is already staged)

func (*Empty_placement_smufl) CommitVoid 

func (empty_placement_smufl *Empty_placement_smufl) CommitVoid(stage *StageStruct)

func (*Empty_placement_smufl) CopyBasicFields 

func (from *Empty_placement_smufl) CopyBasicFields(to *Empty_placement_smufl)

func (*Empty_placement_smufl) GetName 

func (empty_placement_smufl *Empty_placement_smufl) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_placement_smufl) Stage 

func (empty_placement_smufl *Empty_placement_smufl) Stage(stage *StageStruct) *Empty_placement_smufl

Stage puts empty_placement_smufl to the model stage

func (*Empty_placement_smufl) Unstage 

func (empty_placement_smufl *Empty_placement_smufl) Unstage(stage *StageStruct) *Empty_placement_smufl

Unstage removes empty_placement_smufl off the model stage

func (*Empty_placement_smufl) UnstageVoid 

func (empty_placement_smufl *Empty_placement_smufl) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_placement_smufl off the model stage

type Empty_placement_smufl_WOP 

type Empty_placement_smufl_WOP struct {
	// insertion point
	Name string
}

type Empty_print_object_style_align 

type Empty_print_object_style_align struct {
	Name string
}

func CopyBranchEmpty_print_object_style_align 

func CopyBranchEmpty_print_object_style_align(mapOrigCopy map[any]any, empty_print_object_style_alignFrom *Empty_print_object_style_align) (empty_print_object_style_alignTo *Empty_print_object_style_align)

func (*Empty_print_object_style_align) Checkout 

func (empty_print_object_style_align *Empty_print_object_style_align) Checkout(stage *StageStruct) *Empty_print_object_style_align

Checkout empty_print_object_style_align to the back repo (if it is already staged)

func (*Empty_print_object_style_align) Commit 

func (empty_print_object_style_align *Empty_print_object_style_align) Commit(stage *StageStruct) *Empty_print_object_style_align

commit empty_print_object_style_align to the back repo (if it is already staged)

func (*Empty_print_object_style_align) CommitVoid 

func (empty_print_object_style_align *Empty_print_object_style_align) CommitVoid(stage *StageStruct)

func (*Empty_print_object_style_align) CopyBasicFields 

func (from *Empty_print_object_style_align) CopyBasicFields(to *Empty_print_object_style_align)

func (*Empty_print_object_style_align) GetName 

func (empty_print_object_style_align *Empty_print_object_style_align) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_print_object_style_align) Stage 

func (empty_print_object_style_align *Empty_print_object_style_align) Stage(stage *StageStruct) *Empty_print_object_style_align

Stage puts empty_print_object_style_align to the model stage

func (*Empty_print_object_style_align) Unstage 

func (empty_print_object_style_align *Empty_print_object_style_align) Unstage(stage *StageStruct) *Empty_print_object_style_align

Unstage removes empty_print_object_style_align off the model stage

func (*Empty_print_object_style_align) UnstageVoid 

func (empty_print_object_style_align *Empty_print_object_style_align) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_print_object_style_align off the model stage

type Empty_print_object_style_align_WOP 

type Empty_print_object_style_align_WOP struct {
	// insertion point
	Name string
}

type Empty_print_style 

type Empty_print_style struct {
	Name string
}

func CopyBranchEmpty_print_style 

func CopyBranchEmpty_print_style(mapOrigCopy map[any]any, empty_print_styleFrom *Empty_print_style) (empty_print_styleTo *Empty_print_style)

func (*Empty_print_style) Checkout 

func (empty_print_style *Empty_print_style) Checkout(stage *StageStruct) *Empty_print_style

Checkout empty_print_style to the back repo (if it is already staged)

func (*Empty_print_style) Commit 

func (empty_print_style *Empty_print_style) Commit(stage *StageStruct) *Empty_print_style

commit empty_print_style to the back repo (if it is already staged)

func (*Empty_print_style) CommitVoid 

func (empty_print_style *Empty_print_style) CommitVoid(stage *StageStruct)

func (*Empty_print_style) CopyBasicFields 

func (from *Empty_print_style) CopyBasicFields(to *Empty_print_style)

func (*Empty_print_style) GetName 

func (empty_print_style *Empty_print_style) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_print_style) Stage 

func (empty_print_style *Empty_print_style) Stage(stage *StageStruct) *Empty_print_style

Stage puts empty_print_style to the model stage

func (*Empty_print_style) Unstage 

func (empty_print_style *Empty_print_style) Unstage(stage *StageStruct) *Empty_print_style

Unstage removes empty_print_style off the model stage

func (*Empty_print_style) UnstageVoid 

func (empty_print_style *Empty_print_style) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_print_style off the model stage

type Empty_print_style_WOP 

type Empty_print_style_WOP struct {
	// insertion point
	Name string
}

type Empty_print_style_align 

type Empty_print_style_align struct {
	Name string
}

func CopyBranchEmpty_print_style_align 

func CopyBranchEmpty_print_style_align(mapOrigCopy map[any]any, empty_print_style_alignFrom *Empty_print_style_align) (empty_print_style_alignTo *Empty_print_style_align)

func (*Empty_print_style_align) Checkout 

func (empty_print_style_align *Empty_print_style_align) Checkout(stage *StageStruct) *Empty_print_style_align

Checkout empty_print_style_align to the back repo (if it is already staged)

func (*Empty_print_style_align) Commit 

func (empty_print_style_align *Empty_print_style_align) Commit(stage *StageStruct) *Empty_print_style_align

commit empty_print_style_align to the back repo (if it is already staged)

func (*Empty_print_style_align) CommitVoid 

func (empty_print_style_align *Empty_print_style_align) CommitVoid(stage *StageStruct)

func (*Empty_print_style_align) CopyBasicFields 

func (from *Empty_print_style_align) CopyBasicFields(to *Empty_print_style_align)

func (*Empty_print_style_align) GetName 

func (empty_print_style_align *Empty_print_style_align) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_print_style_align) Stage 

func (empty_print_style_align *Empty_print_style_align) Stage(stage *StageStruct) *Empty_print_style_align

Stage puts empty_print_style_align to the model stage

func (*Empty_print_style_align) Unstage 

func (empty_print_style_align *Empty_print_style_align) Unstage(stage *StageStruct) *Empty_print_style_align

Unstage removes empty_print_style_align off the model stage

func (*Empty_print_style_align) UnstageVoid 

func (empty_print_style_align *Empty_print_style_align) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_print_style_align off the model stage

type Empty_print_style_align_WOP 

type Empty_print_style_align_WOP struct {
	// insertion point
	Name string
}

type Empty_print_style_align_id 

type Empty_print_style_align_id struct {
	Name string
}

func CopyBranchEmpty_print_style_align_id 

func CopyBranchEmpty_print_style_align_id(mapOrigCopy map[any]any, empty_print_style_align_idFrom *Empty_print_style_align_id) (empty_print_style_align_idTo *Empty_print_style_align_id)

func (*Empty_print_style_align_id) Checkout 

func (empty_print_style_align_id *Empty_print_style_align_id) Checkout(stage *StageStruct) *Empty_print_style_align_id

Checkout empty_print_style_align_id to the back repo (if it is already staged)

func (*Empty_print_style_align_id) Commit 

func (empty_print_style_align_id *Empty_print_style_align_id) Commit(stage *StageStruct) *Empty_print_style_align_id

commit empty_print_style_align_id to the back repo (if it is already staged)

func (*Empty_print_style_align_id) CommitVoid 

func (empty_print_style_align_id *Empty_print_style_align_id) CommitVoid(stage *StageStruct)

func (*Empty_print_style_align_id) CopyBasicFields 

func (from *Empty_print_style_align_id) CopyBasicFields(to *Empty_print_style_align_id)

func (*Empty_print_style_align_id) GetName 

func (empty_print_style_align_id *Empty_print_style_align_id) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_print_style_align_id) Stage 

func (empty_print_style_align_id *Empty_print_style_align_id) Stage(stage *StageStruct) *Empty_print_style_align_id

Stage puts empty_print_style_align_id to the model stage

func (*Empty_print_style_align_id) Unstage 

func (empty_print_style_align_id *Empty_print_style_align_id) Unstage(stage *StageStruct) *Empty_print_style_align_id

Unstage removes empty_print_style_align_id off the model stage

func (*Empty_print_style_align_id) UnstageVoid 

func (empty_print_style_align_id *Empty_print_style_align_id) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_print_style_align_id off the model stage

type Empty_print_style_align_id_WOP 

type Empty_print_style_align_id_WOP struct {
	// insertion point
	Name string
}

type Empty_trill_sound 

type Empty_trill_sound struct {
	Name string
}

func CopyBranchEmpty_trill_sound 

func CopyBranchEmpty_trill_sound(mapOrigCopy map[any]any, empty_trill_soundFrom *Empty_trill_sound) (empty_trill_soundTo *Empty_trill_sound)

func (*Empty_trill_sound) Checkout 

func (empty_trill_sound *Empty_trill_sound) Checkout(stage *StageStruct) *Empty_trill_sound

Checkout empty_trill_sound to the back repo (if it is already staged)

func (*Empty_trill_sound) Commit 

func (empty_trill_sound *Empty_trill_sound) Commit(stage *StageStruct) *Empty_trill_sound

commit empty_trill_sound to the back repo (if it is already staged)

func (*Empty_trill_sound) CommitVoid 

func (empty_trill_sound *Empty_trill_sound) CommitVoid(stage *StageStruct)

func (*Empty_trill_sound) CopyBasicFields 

func (from *Empty_trill_sound) CopyBasicFields(to *Empty_trill_sound)

func (*Empty_trill_sound) GetName 

func (empty_trill_sound *Empty_trill_sound) GetName() (res string)

for satisfaction of GongStruct interface

func (*Empty_trill_sound) Stage 

func (empty_trill_sound *Empty_trill_sound) Stage(stage *StageStruct) *Empty_trill_sound

Stage puts empty_trill_sound to the model stage

func (*Empty_trill_sound) Unstage 

func (empty_trill_sound *Empty_trill_sound) Unstage(stage *StageStruct) *Empty_trill_sound

Unstage removes empty_trill_sound off the model stage

func (*Empty_trill_sound) UnstageVoid 

func (empty_trill_sound *Empty_trill_sound) UnstageVoid(stage *StageStruct)

UnstageVoid removes empty_trill_sound off the model stage

type Empty_trill_sound_WOP 

type Empty_trill_sound_WOP struct {
	// insertion point
	Name string
}

type Enclosure_shape 

type Enclosure_shape string
const (
	Enclosure_shapeRectangle Enclosure_shape = "rectangle"

	Enclosure_shapeSquare Enclosure_shape = "square"

	Enclosure_shapeOval Enclosure_shape = "oval"

	Enclosure_shapeCircle Enclosure_shape = "circle"

	Enclosure_shapeBracket Enclosure_shape = "bracket"

	Enclosure_shapeInverted_bracket Enclosure_shape = "inverted-bracket"

	Enclosure_shapeTriangle Enclosure_shape = "triangle"

	Enclosure_shapeDiamond Enclosure_shape = "diamond"

	Enclosure_shapePentagon Enclosure_shape = "pentagon"

	Enclosure_shapeHexagon Enclosure_shape = "hexagon"

	Enclosure_shapeHeptagon Enclosure_shape = "heptagon"

	Enclosure_shapeOctagon Enclosure_shape = "octagon"

	Enclosure_shapeNonagon Enclosure_shape = "nonagon"

	Enclosure_shapeDecagon Enclosure_shape = "decagon"

	Enclosure_shapeNone Enclosure_shape = "none"
)

func (Enclosure_shape) CodeValues 

func (enclosure_shape Enclosure_shape) CodeValues() (res []string)

func (Enclosure_shape) Codes 

func (enclosure_shape Enclosure_shape) Codes() (res []string)

func (*Enclosure_shape) FromCodeString 

func (enclosure_shape *Enclosure_shape) FromCodeString(input string) (err error)

func (*Enclosure_shape) FromString 

func (enclosure_shape *Enclosure_shape) FromString(input string) (err error)

func (*Enclosure_shape) ToCodeString 

func (enclosure_shape *Enclosure_shape) ToCodeString() (res string)

func (Enclosure_shape) ToString 

func (enclosure_shape Enclosure_shape) ToString() (res string)

Utility function for Enclosure_shape if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Encoding 

type Encoding struct {
	Name          string
	Encoding_date *Yyyy_mm_dd `xml:"encoding-date,omitempty" json:"encoding-date,omitempty"`

	Encoder *Typed_text `xml:"encoder,omitempty" json:"encoder,omitempty"`

	Software string `xml:"software,omitempty" json:"software,omitempty"`

	Encoding_description string `xml:"encoding-description,omitempty" json:"encoding-description,omitempty"`

	Supports *Supports `xml:"supports,omitempty" json:"supports,omitempty"`
}

func CopyBranchEncoding 

func CopyBranchEncoding(mapOrigCopy map[any]any, encodingFrom *Encoding) (encodingTo *Encoding)

func (*Encoding) Checkout 

func (encoding *Encoding) Checkout(stage *StageStruct) *Encoding

Checkout encoding to the back repo (if it is already staged)

func (*Encoding) Commit 

func (encoding *Encoding) Commit(stage *StageStruct) *Encoding

commit encoding to the back repo (if it is already staged)

func (*Encoding) CommitVoid 

func (encoding *Encoding) CommitVoid(stage *StageStruct)

func (*Encoding) CopyBasicFields 

func (from *Encoding) CopyBasicFields(to *Encoding)

func (*Encoding) GetName 

func (encoding *Encoding) GetName() (res string)

for satisfaction of GongStruct interface

func (*Encoding) Stage 

func (encoding *Encoding) Stage(stage *StageStruct) *Encoding

Stage puts encoding to the model stage

func (*Encoding) Unstage 

func (encoding *Encoding) Unstage(stage *StageStruct) *Encoding

Unstage removes encoding off the model stage

func (*Encoding) UnstageVoid 

func (encoding *Encoding) UnstageVoid(stage *StageStruct)

UnstageVoid removes encoding off the model stage

type Encoding_WOP 

type Encoding_WOP struct {
	// insertion point
	Name                 string
	Software             string
	Encoding_description string
}

type Ending 

type Ending struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Number *Ending_number `xml:"number,attr,omitempty" json:"number,omitempty"`

	Type *Start_stop_discontinue `xml:"type,attr,omitempty" json:"type,omitempty"`

	End_length *Tenths `xml:"end-length,attr,omitempty" json:"end-length,omitempty"`

	Text_x *Tenths `xml:"text-x,attr,omitempty" json:"text-x,omitempty"`

	Text_y *Tenths `xml:"text-y,attr,omitempty" json:"text-y,omitempty"`
}

func CopyBranchEnding 

func CopyBranchEnding(mapOrigCopy map[any]any, endingFrom *Ending) (endingTo *Ending)

func (*Ending) Checkout 

func (ending *Ending) Checkout(stage *StageStruct) *Ending

Checkout ending to the back repo (if it is already staged)

func (*Ending) Commit 

func (ending *Ending) Commit(stage *StageStruct) *Ending

commit ending to the back repo (if it is already staged)

func (*Ending) CommitVoid 

func (ending *Ending) CommitVoid(stage *StageStruct)

func (*Ending) CopyBasicFields 

func (from *Ending) CopyBasicFields(to *Ending)

func (*Ending) GetName 

func (ending *Ending) GetName() (res string)

for satisfaction of GongStruct interface

func (*Ending) Stage 

func (ending *Ending) Stage(stage *StageStruct) *Ending

Stage puts ending to the model stage

func (*Ending) Unstage 

func (ending *Ending) Unstage(stage *StageStruct) *Ending

Unstage removes ending off the model stage

func (*Ending) UnstageVoid 

func (ending *Ending) UnstageVoid(stage *StageStruct)

UnstageVoid removes ending off the model stage

type Ending_WOP 

type Ending_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Ending_number 

type Ending_number string

func (Ending_number) CodeValues 

func (ending_number Ending_number) CodeValues() (res []string)

func (Ending_number) Codes 

func (ending_number Ending_number) Codes() (res []string)

func (*Ending_number) FromCodeString 

func (ending_number *Ending_number) FromCodeString(input string) (err error)

func (*Ending_number) FromString 

func (ending_number *Ending_number) FromString(input string) (err error)

func (*Ending_number) ToCodeString 

func (ending_number *Ending_number) ToCodeString() (res string)

func (Ending_number) ToString 

func (ending_number Ending_number) ToString() (res string)

Utility function for Ending_number if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type ExcelizeTabulator 

type ExcelizeTabulator struct {
	// contains filtered or unexported fields
}

func (*ExcelizeTabulator) AddCell 

func (tab *ExcelizeTabulator) AddCell(sheetName string, rowId, columnIndex int, value string)

func (*ExcelizeTabulator) AddRow 

func (tab *ExcelizeTabulator) AddRow(sheetName string) (rowId int)

func (*ExcelizeTabulator) AddSheet 

func (tab *ExcelizeTabulator) AddSheet(sheetName string)

func (*ExcelizeTabulator) SetExcelizeFile 

func (tab *ExcelizeTabulator) SetExcelizeFile(f *excelize.File)

type Extend 

type Extend struct {
	Name string
	Type *Start_stop_continue `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchExtend 

func CopyBranchExtend(mapOrigCopy map[any]any, extendFrom *Extend) (extendTo *Extend)

func (*Extend) Checkout 

func (extend *Extend) Checkout(stage *StageStruct) *Extend

Checkout extend to the back repo (if it is already staged)

func (*Extend) Commit 

func (extend *Extend) Commit(stage *StageStruct) *Extend

commit extend to the back repo (if it is already staged)

func (*Extend) CommitVoid 

func (extend *Extend) CommitVoid(stage *StageStruct)

func (*Extend) CopyBasicFields 

func (from *Extend) CopyBasicFields(to *Extend)

func (*Extend) GetName 

func (extend *Extend) GetName() (res string)

for satisfaction of GongStruct interface

func (*Extend) Stage 

func (extend *Extend) Stage(stage *StageStruct) *Extend

Stage puts extend to the model stage

func (*Extend) Unstage 

func (extend *Extend) Unstage(stage *StageStruct) *Extend

Unstage removes extend off the model stage

func (*Extend) UnstageVoid 

func (extend *Extend) UnstageVoid(stage *StageStruct)

UnstageVoid removes extend off the model stage

type Extend_WOP 

type Extend_WOP struct {
	// insertion point
	Name string
}

type Fan 

type Fan string
const (
	FanAccel Fan = "accel"

	FanRit Fan = "rit"

	FanNone Fan = "none"
)

func (Fan) CodeValues 

func (fan Fan) CodeValues() (res []string)

func (Fan) Codes 

func (fan Fan) Codes() (res []string)

func (*Fan) FromCodeString 

func (fan *Fan) FromCodeString(input string) (err error)

func (*Fan) FromString 

func (fan *Fan) FromString(input string) (err error)

func (*Fan) ToCodeString 

func (fan *Fan) ToCodeString() (res string)

func (Fan) ToString 

func (fan Fan) ToString() (res string)

Utility function for Fan if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Fault 

type Fault struct {
	XMLName xml.Name `xml:"SOAP-ENV:Fault"`
	Space   string   `xml:"xmlns:SOAP-ENV,omitempty,attr"`

	Code   string `xml:"faultcode,omitempty"`
	String string `xml:"faultstring,omitempty"`
	Actor  string `xml:"faultactor,omitempty"`
	Detail string `xml:"detail,omitempty"`
}

type Feature 

type Feature struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type string `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchFeature 

func CopyBranchFeature(mapOrigCopy map[any]any, featureFrom *Feature) (featureTo *Feature)

func (*Feature) Checkout 

func (feature *Feature) Checkout(stage *StageStruct) *Feature

Checkout feature to the back repo (if it is already staged)

func (*Feature) Commit 

func (feature *Feature) Commit(stage *StageStruct) *Feature

commit feature to the back repo (if it is already staged)

func (*Feature) CommitVoid 

func (feature *Feature) CommitVoid(stage *StageStruct)

func (*Feature) CopyBasicFields 

func (from *Feature) CopyBasicFields(to *Feature)

func (*Feature) GetName 

func (feature *Feature) GetName() (res string)

for satisfaction of GongStruct interface

func (*Feature) Stage 

func (feature *Feature) Stage(stage *StageStruct) *Feature

Stage puts feature to the model stage

func (*Feature) Unstage 

func (feature *Feature) Unstage(stage *StageStruct) *Feature

Unstage removes feature off the model stage

func (*Feature) UnstageVoid 

func (feature *Feature) UnstageVoid(stage *StageStruct)

UnstageVoid removes feature off the model stage

type Feature_WOP 

type Feature_WOP struct {
	// insertion point
	Name  string
	Value string
	Type  string
}

type Fermata 

type Fermata struct {
	Name  string
	Value *Fermata_shape `xml:",chardata" json:"-,"`

	Type *Upright_inverted `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchFermata 

func CopyBranchFermata(mapOrigCopy map[any]any, fermataFrom *Fermata) (fermataTo *Fermata)

func (*Fermata) Checkout 

func (fermata *Fermata) Checkout(stage *StageStruct) *Fermata

Checkout fermata to the back repo (if it is already staged)

func (*Fermata) Commit 

func (fermata *Fermata) Commit(stage *StageStruct) *Fermata

commit fermata to the back repo (if it is already staged)

func (*Fermata) CommitVoid 

func (fermata *Fermata) CommitVoid(stage *StageStruct)

func (*Fermata) CopyBasicFields 

func (from *Fermata) CopyBasicFields(to *Fermata)

func (*Fermata) GetName 

func (fermata *Fermata) GetName() (res string)

for satisfaction of GongStruct interface

func (*Fermata) Stage 

func (fermata *Fermata) Stage(stage *StageStruct) *Fermata

Stage puts fermata to the model stage

func (*Fermata) Unstage 

func (fermata *Fermata) Unstage(stage *StageStruct) *Fermata

Unstage removes fermata off the model stage

func (*Fermata) UnstageVoid 

func (fermata *Fermata) UnstageVoid(stage *StageStruct)

UnstageVoid removes fermata off the model stage

type Fermata_WOP 

type Fermata_WOP struct {
	// insertion point
	Name string
}

type Fermata_shape 

type Fermata_shape string
const (
	Fermata_shapeNormal Fermata_shape = "normal"

	Fermata_shapeAngled Fermata_shape = "angled"

	Fermata_shapeSquare Fermata_shape = "square"

	Fermata_shapeDouble_angled Fermata_shape = "double-angled"

	Fermata_shapeDouble_square Fermata_shape = "double-square"

	Fermata_shapeDouble_dot Fermata_shape = "double-dot"

	Fermata_shapeHalf_curve Fermata_shape = "half-curve"

	Fermata_shapeCurlew Fermata_shape = "curlew"

	Fermata_shapeEmptyString Fermata_shape = ""
)

func (Fermata_shape) CodeValues 

func (fermata_shape Fermata_shape) CodeValues() (res []string)

func (Fermata_shape) Codes 

func (fermata_shape Fermata_shape) Codes() (res []string)

func (*Fermata_shape) FromCodeString 

func (fermata_shape *Fermata_shape) FromCodeString(input string) (err error)

func (*Fermata_shape) FromString 

func (fermata_shape *Fermata_shape) FromString(input string) (err error)

func (*Fermata_shape) ToCodeString 

func (fermata_shape *Fermata_shape) ToCodeString() (res string)

func (Fermata_shape) ToString 

func (fermata_shape Fermata_shape) ToString() (res string)

Utility function for Fermata_shape if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Fifths 

type Fifths int32

type Figure 

type Figure struct {
	Name string

	// Values for the prefix element include plus and the accidental
	// values sharp, flat, natural, double-sharp, flat-flat, and sharp-sharp. The
	// prefix element may contain additional values for symbols specific to
	// particular figured bass styles.
	Prefix *Style_text `xml:"prefix,omitempty" json:"prefix,omitempty"`

	// A figure-number is a number. Overstrikes of the figure number
	// are represented in the suffix element.
	Figure_number *Style_text `xml:"figure-number,omitempty" json:"figure-number,omitempty"`

	// Values for the suffix element include plus and the accidental
	// values sharp, flat, natural, double-sharp, flat-flat, and sharp-sharp.
	// Suffixes include both symbols that come after the figure number and those
	// that overstrike the figure number. The suffix values slash, back-slash, and
	// vertical are used for slashed numbers indicating chromatic alteration. The
	// orientation and display of the slash usually depends on the figure number.
	// The suffix element may contain additional values for symbols specific to
	// particular figured bass styles.
	Suffix *Style_text `xml:"suffix,omitempty" json:"suffix,omitempty"`

	Extend *Extend `xml:"extend,omitempty" json:"extend,omitempty"`
}

func CopyBranchFigure 

func CopyBranchFigure(mapOrigCopy map[any]any, figureFrom *Figure) (figureTo *Figure)

func (*Figure) Checkout 

func (figure *Figure) Checkout(stage *StageStruct) *Figure

Checkout figure to the back repo (if it is already staged)

func (*Figure) Commit 

func (figure *Figure) Commit(stage *StageStruct) *Figure

commit figure to the back repo (if it is already staged)

func (*Figure) CommitVoid 

func (figure *Figure) CommitVoid(stage *StageStruct)

func (*Figure) CopyBasicFields 

func (from *Figure) CopyBasicFields(to *Figure)

func (*Figure) GetName 

func (figure *Figure) GetName() (res string)

for satisfaction of GongStruct interface

func (*Figure) Stage 

func (figure *Figure) Stage(stage *StageStruct) *Figure

Stage puts figure to the model stage

func (*Figure) Unstage 

func (figure *Figure) Unstage(stage *StageStruct) *Figure

Unstage removes figure off the model stage

func (*Figure) UnstageVoid 

func (figure *Figure) UnstageVoid(stage *StageStruct)

UnstageVoid removes figure off the model stage

type Figure_WOP 

type Figure_WOP struct {
	// insertion point
	Name string
}

type Figured_bass 

type Figured_bass struct {
	Name   string
	Figure []*Figure `xml:"figure,omitempty" json:"figure,omitempty"`

	Parentheses *Yes_no `xml:"parentheses,attr,omitempty" json:"parentheses,omitempty"`
}

func CopyBranchFigured_bass 

func CopyBranchFigured_bass(mapOrigCopy map[any]any, figured_bassFrom *Figured_bass) (figured_bassTo *Figured_bass)

func (*Figured_bass) Checkout 

func (figured_bass *Figured_bass) Checkout(stage *StageStruct) *Figured_bass

Checkout figured_bass to the back repo (if it is already staged)

func (*Figured_bass) Commit 

func (figured_bass *Figured_bass) Commit(stage *StageStruct) *Figured_bass

commit figured_bass to the back repo (if it is already staged)

func (*Figured_bass) CommitVoid 

func (figured_bass *Figured_bass) CommitVoid(stage *StageStruct)

func (*Figured_bass) CopyBasicFields 

func (from *Figured_bass) CopyBasicFields(to *Figured_bass)

func (*Figured_bass) GetName 

func (figured_bass *Figured_bass) GetName() (res string)

for satisfaction of GongStruct interface

func (*Figured_bass) Stage 

func (figured_bass *Figured_bass) Stage(stage *StageStruct) *Figured_bass

Stage puts figured_bass to the model stage

func (*Figured_bass) Unstage 

func (figured_bass *Figured_bass) Unstage(stage *StageStruct) *Figured_bass

Unstage removes figured_bass off the model stage

func (*Figured_bass) UnstageVoid 

func (figured_bass *Figured_bass) UnstageVoid(stage *StageStruct)

UnstageVoid removes figured_bass off the model stage

type Figured_bass_WOP 

type Figured_bass_WOP struct {
	// insertion point
	Name string
}

type Fingering 

type Fingering struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Substitution *Yes_no `xml:"substitution,attr,omitempty" json:"substitution,omitempty"`

	Alternate *Yes_no `xml:"alternate,attr,omitempty" json:"alternate,omitempty"`
}

func CopyBranchFingering 

func CopyBranchFingering(mapOrigCopy map[any]any, fingeringFrom *Fingering) (fingeringTo *Fingering)

func (*Fingering) Checkout 

func (fingering *Fingering) Checkout(stage *StageStruct) *Fingering

Checkout fingering to the back repo (if it is already staged)

func (*Fingering) Commit 

func (fingering *Fingering) Commit(stage *StageStruct) *Fingering

commit fingering to the back repo (if it is already staged)

func (*Fingering) CommitVoid 

func (fingering *Fingering) CommitVoid(stage *StageStruct)

func (*Fingering) CopyBasicFields 

func (from *Fingering) CopyBasicFields(to *Fingering)

func (*Fingering) GetName 

func (fingering *Fingering) GetName() (res string)

for satisfaction of GongStruct interface

func (*Fingering) Stage 

func (fingering *Fingering) Stage(stage *StageStruct) *Fingering

Stage puts fingering to the model stage

func (*Fingering) Unstage 

func (fingering *Fingering) Unstage(stage *StageStruct) *Fingering

Unstage removes fingering off the model stage

func (*Fingering) UnstageVoid 

func (fingering *Fingering) UnstageVoid(stage *StageStruct)

UnstageVoid removes fingering off the model stage

type Fingering_WOP 

type Fingering_WOP struct {
	// insertion point
	Name  string
	Value string
}

type First_fret 

type First_fret struct {
	Name  string
	Value *PositiveInteger `xml:",chardata" json:"-,"`

	Text string `xml:"text,attr,omitempty" json:"text,omitempty"`

	Location *Left_right `xml:"location,attr,omitempty" json:"location,omitempty"`
}

func CopyBranchFirst_fret 

func CopyBranchFirst_fret(mapOrigCopy map[any]any, first_fretFrom *First_fret) (first_fretTo *First_fret)

func (*First_fret) Checkout 

func (first_fret *First_fret) Checkout(stage *StageStruct) *First_fret

Checkout first_fret to the back repo (if it is already staged)

func (*First_fret) Commit 

func (first_fret *First_fret) Commit(stage *StageStruct) *First_fret

commit first_fret to the back repo (if it is already staged)

func (*First_fret) CommitVoid 

func (first_fret *First_fret) CommitVoid(stage *StageStruct)

func (*First_fret) CopyBasicFields 

func (from *First_fret) CopyBasicFields(to *First_fret)

func (*First_fret) GetName 

func (first_fret *First_fret) GetName() (res string)

for satisfaction of GongStruct interface

func (*First_fret) Stage 

func (first_fret *First_fret) Stage(stage *StageStruct) *First_fret

Stage puts first_fret to the model stage

func (*First_fret) Unstage 

func (first_fret *First_fret) Unstage(stage *StageStruct) *First_fret

Unstage removes first_fret off the model stage

func (*First_fret) UnstageVoid 

func (first_fret *First_fret) UnstageVoid(stage *StageStruct)

UnstageVoid removes first_fret off the model stage

type First_fret_WOP 

type First_fret_WOP struct {
	// insertion point
	Name string
	Text string
}

type Font_family 

type Font_family Comma_separated_text

type Font_size 

type Font_size string

func (Font_size) CodeValues 

func (font_size Font_size) CodeValues() (res []string)

func (Font_size) Codes 

func (font_size Font_size) Codes() (res []string)

func (*Font_size) FromCodeString 

func (font_size *Font_size) FromCodeString(input string) (err error)

func (*Font_size) FromString 

func (font_size *Font_size) FromString(input string) (err error)

func (*Font_size) ToCodeString 

func (font_size *Font_size) ToCodeString() (res string)

func (Font_size) ToString 

func (font_size Font_size) ToString() (res string)

Utility function for Font_size if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Font_style 

type Font_style string
const (
	Font_styleNormal Font_style = "normal"

	Font_styleItalic Font_style = "italic"
)

func (Font_style) CodeValues 

func (font_style Font_style) CodeValues() (res []string)

func (Font_style) Codes 

func (font_style Font_style) Codes() (res []string)

func (*Font_style) FromCodeString 

func (font_style *Font_style) FromCodeString(input string) (err error)

func (*Font_style) FromString 

func (font_style *Font_style) FromString(input string) (err error)

func (*Font_style) ToCodeString 

func (font_style *Font_style) ToCodeString() (res string)

func (Font_style) ToString 

func (font_style Font_style) ToString() (res string)

Utility function for Font_style if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Font_weight 

type Font_weight string
const (
	Font_weightNormal Font_weight = "normal"

	Font_weightBold Font_weight = "bold"
)

func (Font_weight) CodeValues 

func (font_weight Font_weight) CodeValues() (res []string)

func (Font_weight) Codes 

func (font_weight Font_weight) Codes() (res []string)

func (*Font_weight) FromCodeString 

func (font_weight *Font_weight) FromCodeString(input string) (err error)

func (*Font_weight) FromString 

func (font_weight *Font_weight) FromString(input string) (err error)

func (*Font_weight) ToCodeString 

func (font_weight *Font_weight) ToCodeString() (res string)

func (Font_weight) ToString 

func (font_weight Font_weight) ToString() (res string)

Utility function for Font_weight if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Foo 

type Foo struct {
	Name string
}

func CopyBranchFoo 

func CopyBranchFoo(mapOrigCopy map[any]any, fooFrom *Foo) (fooTo *Foo)

func (*Foo) Checkout 

func (foo *Foo) Checkout(stage *StageStruct) *Foo

Checkout foo to the back repo (if it is already staged)

func (*Foo) Commit 

func (foo *Foo) Commit(stage *StageStruct) *Foo

commit foo to the back repo (if it is already staged)

func (*Foo) CommitVoid 

func (foo *Foo) CommitVoid(stage *StageStruct)

func (*Foo) CopyBasicFields 

func (from *Foo) CopyBasicFields(to *Foo)

func (*Foo) GetName 

func (foo *Foo) GetName() (res string)

for satisfaction of GongStruct interface

func (*Foo) Stage 

func (foo *Foo) Stage(stage *StageStruct) *Foo

Stage puts foo to the model stage

func (*Foo) Unstage 

func (foo *Foo) Unstage(stage *StageStruct) *Foo

Unstage removes foo off the model stage

func (*Foo) UnstageVoid 

func (foo *Foo) UnstageVoid(stage *StageStruct)

UnstageVoid removes foo off the model stage

type Foo_WOP 

type Foo_WOP struct {
	// insertion point
	Name string
}

type For_part 

type For_part struct {
	Name string

	// The part-clef element is used for transpositions that also
	// include a change of clef, as for instruments such as bass clarinet.
	Part_clef *Part_clef `xml:"part-clef,omitempty" json:"part-clef,omitempty"`

	// The chromatic element in a part-transpose element will usually
	// have a non-zero value, since octave transpositions can be represented in
	// concert scores using the transpose element.
	Part_transpose *Part_transpose `xml:"part-transpose,omitempty" json:"part-transpose,omitempty"`

	Number *Staff_number `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchFor_part 

func CopyBranchFor_part(mapOrigCopy map[any]any, for_partFrom *For_part) (for_partTo *For_part)

func (*For_part) Checkout 

func (for_part *For_part) Checkout(stage *StageStruct) *For_part

Checkout for_part to the back repo (if it is already staged)

func (*For_part) Commit 

func (for_part *For_part) Commit(stage *StageStruct) *For_part

commit for_part to the back repo (if it is already staged)

func (*For_part) CommitVoid 

func (for_part *For_part) CommitVoid(stage *StageStruct)

func (*For_part) CopyBasicFields 

func (from *For_part) CopyBasicFields(to *For_part)

func (*For_part) GetName 

func (for_part *For_part) GetName() (res string)

for satisfaction of GongStruct interface

func (*For_part) Stage 

func (for_part *For_part) Stage(stage *StageStruct) *For_part

Stage puts for_part to the model stage

func (*For_part) Unstage 

func (for_part *For_part) Unstage(stage *StageStruct) *For_part

Unstage removes for_part off the model stage

func (*For_part) UnstageVoid 

func (for_part *For_part) UnstageVoid(stage *StageStruct)

UnstageVoid removes for_part off the model stage

type For_part_WOP 

type For_part_WOP struct {
	// insertion point
	Name string
}

type Formatted_symbol 

type Formatted_symbol struct {
	Name  string
	Value *Smufl_glyph_name `xml:",chardata" json:"-,"`
}

func CopyBranchFormatted_symbol 

func CopyBranchFormatted_symbol(mapOrigCopy map[any]any, formatted_symbolFrom *Formatted_symbol) (formatted_symbolTo *Formatted_symbol)

func (*Formatted_symbol) Checkout 

func (formatted_symbol *Formatted_symbol) Checkout(stage *StageStruct) *Formatted_symbol

Checkout formatted_symbol to the back repo (if it is already staged)

func (*Formatted_symbol) Commit 

func (formatted_symbol *Formatted_symbol) Commit(stage *StageStruct) *Formatted_symbol

commit formatted_symbol to the back repo (if it is already staged)

func (*Formatted_symbol) CommitVoid 

func (formatted_symbol *Formatted_symbol) CommitVoid(stage *StageStruct)

func (*Formatted_symbol) CopyBasicFields 

func (from *Formatted_symbol) CopyBasicFields(to *Formatted_symbol)

func (*Formatted_symbol) GetName 

func (formatted_symbol *Formatted_symbol) GetName() (res string)

for satisfaction of GongStruct interface

func (*Formatted_symbol) Stage 

func (formatted_symbol *Formatted_symbol) Stage(stage *StageStruct) *Formatted_symbol

Stage puts formatted_symbol to the model stage

func (*Formatted_symbol) Unstage 

func (formatted_symbol *Formatted_symbol) Unstage(stage *StageStruct) *Formatted_symbol

Unstage removes formatted_symbol off the model stage

func (*Formatted_symbol) UnstageVoid 

func (formatted_symbol *Formatted_symbol) UnstageVoid(stage *StageStruct)

UnstageVoid removes formatted_symbol off the model stage

type Formatted_symbol_WOP 

type Formatted_symbol_WOP struct {
	// insertion point
	Name string
}

type Formatted_symbol_id 

type Formatted_symbol_id struct {
	Name  string
	Value *Smufl_glyph_name `xml:",chardata" json:"-,"`
}

func CopyBranchFormatted_symbol_id 

func CopyBranchFormatted_symbol_id(mapOrigCopy map[any]any, formatted_symbol_idFrom *Formatted_symbol_id) (formatted_symbol_idTo *Formatted_symbol_id)

func (*Formatted_symbol_id) Checkout 

func (formatted_symbol_id *Formatted_symbol_id) Checkout(stage *StageStruct) *Formatted_symbol_id

Checkout formatted_symbol_id to the back repo (if it is already staged)

func (*Formatted_symbol_id) Commit 

func (formatted_symbol_id *Formatted_symbol_id) Commit(stage *StageStruct) *Formatted_symbol_id

commit formatted_symbol_id to the back repo (if it is already staged)

func (*Formatted_symbol_id) CommitVoid 

func (formatted_symbol_id *Formatted_symbol_id) CommitVoid(stage *StageStruct)

func (*Formatted_symbol_id) CopyBasicFields 

func (from *Formatted_symbol_id) CopyBasicFields(to *Formatted_symbol_id)

func (*Formatted_symbol_id) GetName 

func (formatted_symbol_id *Formatted_symbol_id) GetName() (res string)

for satisfaction of GongStruct interface

func (*Formatted_symbol_id) Stage 

func (formatted_symbol_id *Formatted_symbol_id) Stage(stage *StageStruct) *Formatted_symbol_id

Stage puts formatted_symbol_id to the model stage

func (*Formatted_symbol_id) Unstage 

func (formatted_symbol_id *Formatted_symbol_id) Unstage(stage *StageStruct) *Formatted_symbol_id

Unstage removes formatted_symbol_id off the model stage

func (*Formatted_symbol_id) UnstageVoid 

func (formatted_symbol_id *Formatted_symbol_id) UnstageVoid(stage *StageStruct)

UnstageVoid removes formatted_symbol_id off the model stage

type Formatted_symbol_id_WOP 

type Formatted_symbol_id_WOP struct {
	// insertion point
	Name string
}

type Formatted_text 

type Formatted_text string

func (Formatted_text) CodeValues 

func (formatted_text Formatted_text) CodeValues() (res []string)

func (Formatted_text) Codes 

func (formatted_text Formatted_text) Codes() (res []string)

func (*Formatted_text) FromCodeString 

func (formatted_text *Formatted_text) FromCodeString(input string) (err error)

func (*Formatted_text) FromString 

func (formatted_text *Formatted_text) FromString(input string) (err error)

func (*Formatted_text) ToCodeString 

func (formatted_text *Formatted_text) ToCodeString() (res string)

func (Formatted_text) ToString 

func (formatted_text Formatted_text) ToString() (res string)

Utility function for Formatted_text if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Formatted_text_id 

type Formatted_text_id string

func (Formatted_text_id) CodeValues 

func (formatted_text_id Formatted_text_id) CodeValues() (res []string)

func (Formatted_text_id) Codes 

func (formatted_text_id Formatted_text_id) Codes() (res []string)

func (*Formatted_text_id) FromCodeString 

func (formatted_text_id *Formatted_text_id) FromCodeString(input string) (err error)

func (*Formatted_text_id) FromString 

func (formatted_text_id *Formatted_text_id) FromString(input string) (err error)

func (*Formatted_text_id) ToCodeString 

func (formatted_text_id *Formatted_text_id) ToCodeString() (res string)

func (Formatted_text_id) ToString 

func (formatted_text_id Formatted_text_id) ToString() (res string)

Utility function for Formatted_text_id if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Forward 

type Forward struct {
	Name string
}

func CopyBranchForward 

func CopyBranchForward(mapOrigCopy map[any]any, forwardFrom *Forward) (forwardTo *Forward)

func (*Forward) Checkout 

func (forward *Forward) Checkout(stage *StageStruct) *Forward

Checkout forward to the back repo (if it is already staged)

func (*Forward) Commit 

func (forward *Forward) Commit(stage *StageStruct) *Forward

commit forward to the back repo (if it is already staged)

func (*Forward) CommitVoid 

func (forward *Forward) CommitVoid(stage *StageStruct)

func (*Forward) CopyBasicFields 

func (from *Forward) CopyBasicFields(to *Forward)

func (*Forward) GetName 

func (forward *Forward) GetName() (res string)

for satisfaction of GongStruct interface

func (*Forward) Stage 

func (forward *Forward) Stage(stage *StageStruct) *Forward

Stage puts forward to the model stage

func (*Forward) Unstage 

func (forward *Forward) Unstage(stage *StageStruct) *Forward

Unstage removes forward off the model stage

func (*Forward) UnstageVoid 

func (forward *Forward) UnstageVoid(stage *StageStruct)

UnstageVoid removes forward off the model stage

type Forward_WOP 

type Forward_WOP struct {
	// insertion point
	Name string
}

type Frame 

type Frame struct {
	Name string

	// The frame-strings element gives the overall size of the frame
	// in vertical lines (strings).
	Frame_strings *PositiveInteger `xml:"frame-strings,omitempty" json:"frame-strings,omitempty"`

	// The frame-frets element gives the overall size of the frame in
	// horizontal spaces (frets).
	Frame_frets *PositiveInteger `xml:"frame-frets,omitempty" json:"frame-frets,omitempty"`

	First_fret *First_fret `xml:"first-fret,omitempty" json:"first-fret,omitempty"`

	Frame_note []*Frame_note `xml:"frame-note,omitempty" json:"frame-note,omitempty"`

	Height *Tenths `xml:"height,attr,omitempty" json:"height,omitempty"`

	Width *Tenths `xml:"width,attr,omitempty" json:"width,omitempty"`

	Unplayed string `xml:"unplayed,attr,omitempty" json:"unplayed,omitempty"`
}

func CopyBranchFrame 

func CopyBranchFrame(mapOrigCopy map[any]any, frameFrom *Frame) (frameTo *Frame)

func (*Frame) Checkout 

func (frame *Frame) Checkout(stage *StageStruct) *Frame

Checkout frame to the back repo (if it is already staged)

func (*Frame) Commit 

func (frame *Frame) Commit(stage *StageStruct) *Frame

commit frame to the back repo (if it is already staged)

func (*Frame) CommitVoid 

func (frame *Frame) CommitVoid(stage *StageStruct)

func (*Frame) CopyBasicFields 

func (from *Frame) CopyBasicFields(to *Frame)

func (*Frame) GetName 

func (frame *Frame) GetName() (res string)

for satisfaction of GongStruct interface

func (*Frame) Stage 

func (frame *Frame) Stage(stage *StageStruct) *Frame

Stage puts frame to the model stage

func (*Frame) Unstage 

func (frame *Frame) Unstage(stage *StageStruct) *Frame

Unstage removes frame off the model stage

func (*Frame) UnstageVoid 

func (frame *Frame) UnstageVoid(stage *StageStruct)

UnstageVoid removes frame off the model stage

type Frame_WOP 

type Frame_WOP struct {
	// insertion point
	Name     string
	Unplayed string
}

type Frame_note 

type Frame_note struct {
	Name    string
	Astring string `xml:"string,omitempty" json:"string,omitempty"`

	Fret *Fret `xml:"fret,omitempty" json:"fret,omitempty"`

	Fingering *Fingering `xml:"fingering,omitempty" json:"fingering,omitempty"`

	Barre *Barre `xml:"barre,omitempty" json:"barre,omitempty"`
}

func CopyBranchFrame_note 

func CopyBranchFrame_note(mapOrigCopy map[any]any, frame_noteFrom *Frame_note) (frame_noteTo *Frame_note)

func (*Frame_note) Checkout 

func (frame_note *Frame_note) Checkout(stage *StageStruct) *Frame_note

Checkout frame_note to the back repo (if it is already staged)

func (*Frame_note) Commit 

func (frame_note *Frame_note) Commit(stage *StageStruct) *Frame_note

commit frame_note to the back repo (if it is already staged)

func (*Frame_note) CommitVoid 

func (frame_note *Frame_note) CommitVoid(stage *StageStruct)

func (*Frame_note) CopyBasicFields 

func (from *Frame_note) CopyBasicFields(to *Frame_note)

func (*Frame_note) GetName 

func (frame_note *Frame_note) GetName() (res string)

for satisfaction of GongStruct interface

func (*Frame_note) Stage 

func (frame_note *Frame_note) Stage(stage *StageStruct) *Frame_note

Stage puts frame_note to the model stage

func (*Frame_note) Unstage 

func (frame_note *Frame_note) Unstage(stage *StageStruct) *Frame_note

Unstage removes frame_note off the model stage

func (*Frame_note) UnstageVoid 

func (frame_note *Frame_note) UnstageVoid(stage *StageStruct)

UnstageVoid removes frame_note off the model stage

type Frame_note_WOP 

type Frame_note_WOP struct {
	// insertion point
	Name    string
	Astring string
}

type Fret 

type Fret struct {
	Name  string
	Value uint32 `xml:",chardata" json:"-,"`
}

func CopyBranchFret 

func CopyBranchFret(mapOrigCopy map[any]any, fretFrom *Fret) (fretTo *Fret)

func (*Fret) Checkout 

func (fret *Fret) Checkout(stage *StageStruct) *Fret

Checkout fret to the back repo (if it is already staged)

func (*Fret) Commit 

func (fret *Fret) Commit(stage *StageStruct) *Fret

commit fret to the back repo (if it is already staged)

func (*Fret) CommitVoid 

func (fret *Fret) CommitVoid(stage *StageStruct)

func (*Fret) CopyBasicFields 

func (from *Fret) CopyBasicFields(to *Fret)

func (*Fret) GetName 

func (fret *Fret) GetName() (res string)

for satisfaction of GongStruct interface

func (*Fret) Stage 

func (fret *Fret) Stage(stage *StageStruct) *Fret

Stage puts fret to the model stage

func (*Fret) Unstage 

func (fret *Fret) Unstage(stage *StageStruct) *Fret

Unstage removes fret off the model stage

func (*Fret) UnstageVoid 

func (fret *Fret) UnstageVoid(stage *StageStruct)

UnstageVoid removes fret off the model stage

type Fret_WOP 

type Fret_WOP struct {
	// insertion point
	Name string
}

type GONG__ExpressionType 

type GONG__ExpressionType string

swagger:ignore 

const (
	GONG__STRUCT_INSTANCE      GONG__ExpressionType = "STRUCT_INSTANCE"
	GONG__FIELD_OR_CONST_VALUE GONG__ExpressionType = "FIELD_OR_CONST_VALUE"
	GONG__FIELD_VALUE          GONG__ExpressionType = "FIELD_VALUE"
	GONG__ENUM_CAST_INT        GONG__ExpressionType = "ENUM_CAST_INT"
	GONG__ENUM_CAST_STRING     GONG__ExpressionType = "ENUM_CAST_STRING"
	GONG__IDENTIFIER_CONST     GONG__ExpressionType = "IDENTIFIER_CONST"
)

type GONG__Identifier 

type GONG__Identifier struct {
	Ident string
	Type  GONG__ExpressionType
}

type Glass 

type Glass struct {
	Name  string
	Value *Glass_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_pictogram_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchGlass 

func CopyBranchGlass(mapOrigCopy map[any]any, glassFrom *Glass) (glassTo *Glass)

func (*Glass) Checkout 

func (glass *Glass) Checkout(stage *StageStruct) *Glass

Checkout glass to the back repo (if it is already staged)

func (*Glass) Commit 

func (glass *Glass) Commit(stage *StageStruct) *Glass

commit glass to the back repo (if it is already staged)

func (*Glass) CommitVoid 

func (glass *Glass) CommitVoid(stage *StageStruct)

func (*Glass) CopyBasicFields 

func (from *Glass) CopyBasicFields(to *Glass)

func (*Glass) GetName 

func (glass *Glass) GetName() (res string)

for satisfaction of GongStruct interface

func (*Glass) Stage 

func (glass *Glass) Stage(stage *StageStruct) *Glass

Stage puts glass to the model stage

func (*Glass) Unstage 

func (glass *Glass) Unstage(stage *StageStruct) *Glass

Unstage removes glass off the model stage

func (*Glass) UnstageVoid 

func (glass *Glass) UnstageVoid(stage *StageStruct)

UnstageVoid removes glass off the model stage

type Glass_WOP 

type Glass_WOP struct {
	// insertion point
	Name string
}

type Glass_value 

type Glass_value string
const (
	Glass_valueGlassharmonica Glass_value = "glass harmonica"

	Glass_valueGlassharp Glass_value = "glass harp"

	Glass_valueWindchimes Glass_value = "wind chimes"
)

func (Glass_value) CodeValues 

func (glass_value Glass_value) CodeValues() (res []string)

func (Glass_value) Codes 

func (glass_value Glass_value) Codes() (res []string)

func (*Glass_value) FromCodeString 

func (glass_value *Glass_value) FromCodeString(input string) (err error)

func (*Glass_value) FromString 

func (glass_value *Glass_value) FromString(input string) (err error)

func (*Glass_value) ToCodeString 

func (glass_value *Glass_value) ToCodeString() (res string)

func (Glass_value) ToString 

func (glass_value Glass_value) ToString() (res string)

Utility function for Glass_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Glissando 

type Glissando struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchGlissando 

func CopyBranchGlissando(mapOrigCopy map[any]any, glissandoFrom *Glissando) (glissandoTo *Glissando)

func (*Glissando) Checkout 

func (glissando *Glissando) Checkout(stage *StageStruct) *Glissando

Checkout glissando to the back repo (if it is already staged)

func (*Glissando) Commit 

func (glissando *Glissando) Commit(stage *StageStruct) *Glissando

commit glissando to the back repo (if it is already staged)

func (*Glissando) CommitVoid 

func (glissando *Glissando) CommitVoid(stage *StageStruct)

func (*Glissando) CopyBasicFields 

func (from *Glissando) CopyBasicFields(to *Glissando)

func (*Glissando) GetName 

func (glissando *Glissando) GetName() (res string)

for satisfaction of GongStruct interface

func (*Glissando) Stage 

func (glissando *Glissando) Stage(stage *StageStruct) *Glissando

Stage puts glissando to the model stage

func (*Glissando) Unstage 

func (glissando *Glissando) Unstage(stage *StageStruct) *Glissando

Unstage removes glissando off the model stage

func (*Glissando) UnstageVoid 

func (glissando *Glissando) UnstageVoid(stage *StageStruct)

UnstageVoid removes glissando off the model stage

type Glissando_WOP 

type Glissando_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Glyph 

type Glyph struct {
	Name  string
	Value *Smufl_glyph_name `xml:",chardata" json:"-,"`

	Type *Glyph_type `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchGlyph 

func CopyBranchGlyph(mapOrigCopy map[any]any, glyphFrom *Glyph) (glyphTo *Glyph)

func (*Glyph) Checkout 

func (glyph *Glyph) Checkout(stage *StageStruct) *Glyph

Checkout glyph to the back repo (if it is already staged)

func (*Glyph) Commit 

func (glyph *Glyph) Commit(stage *StageStruct) *Glyph

commit glyph to the back repo (if it is already staged)

func (*Glyph) CommitVoid 

func (glyph *Glyph) CommitVoid(stage *StageStruct)

func (*Glyph) CopyBasicFields 

func (from *Glyph) CopyBasicFields(to *Glyph)

func (*Glyph) GetName 

func (glyph *Glyph) GetName() (res string)

for satisfaction of GongStruct interface

func (*Glyph) Stage 

func (glyph *Glyph) Stage(stage *StageStruct) *Glyph

Stage puts glyph to the model stage

func (*Glyph) Unstage 

func (glyph *Glyph) Unstage(stage *StageStruct) *Glyph

Unstage removes glyph off the model stage

func (*Glyph) UnstageVoid 

func (glyph *Glyph) UnstageVoid(stage *StageStruct)

UnstageVoid removes glyph off the model stage

type Glyph_WOP 

type Glyph_WOP struct {
	// insertion point
	Name string
}

type Glyph_type 

type Glyph_type string

func (Glyph_type) CodeValues 

func (glyph_type Glyph_type) CodeValues() (res []string)

func (Glyph_type) Codes 

func (glyph_type Glyph_type) Codes() (res []string)

func (*Glyph_type) FromCodeString 

func (glyph_type *Glyph_type) FromCodeString(input string) (err error)

func (*Glyph_type) FromString 

func (glyph_type *Glyph_type) FromString(input string) (err error)

func (*Glyph_type) ToCodeString 

func (glyph_type *Glyph_type) ToCodeString() (res string)

func (Glyph_type) ToString 

func (glyph_type Glyph_type) ToString() (res string)

Utility function for Glyph_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type GongStructInterface 

type GongStructInterface interface {
	GetName() (res string)
}

GongStructInterface is the interface met by GongStructs It allows runtime reflexion of instances (without the hassle of the "reflect" package)

type Gongstruct 

type Gongstruct interface {
}

Gongstruct is the type parameter for generated generic function that allows - access to staged instances - navigation between staged instances by going backward association links between gongstruct - full refactoring of Gongstruct identifiers / fields

type GongstructEnumIntField 

type GongstructEnumIntField interface {
	int | PositiveInteger
	Codes() []string
	CodeValues() []int
}

type GongstructEnumStringField 

type GongstructEnumStringField interface {
	Codes() []string
	CodeValues() []string
	ToString() string
}

type GongstructMapString 

type GongstructMapString interface {
	map[any]any
}

type GongstructSet 

type GongstructSet interface {
	map[any]any
}

type GongtructBasicField 

type GongtructBasicField interface {
	int | float64 | bool | string | time.Time | time.Duration
}

type Grace 

type Grace struct {
	Name                string
	Steal_time_previous *Percent `xml:"steal-time-previous,attr,omitempty" json:"steal-time-previous,omitempty"`

	Steal_time_following *Percent `xml:"steal-time-following,attr,omitempty" json:"steal-time-following,omitempty"`

	Make_time *Divisions `xml:"make-time,attr,omitempty" json:"make-time,omitempty"`

	Slash *Yes_no `xml:"slash,attr,omitempty" json:"slash,omitempty"`
}

func CopyBranchGrace 

func CopyBranchGrace(mapOrigCopy map[any]any, graceFrom *Grace) (graceTo *Grace)

func (*Grace) Checkout 

func (grace *Grace) Checkout(stage *StageStruct) *Grace

Checkout grace to the back repo (if it is already staged)

func (*Grace) Commit 

func (grace *Grace) Commit(stage *StageStruct) *Grace

commit grace to the back repo (if it is already staged)

func (*Grace) CommitVoid 

func (grace *Grace) CommitVoid(stage *StageStruct)

func (*Grace) CopyBasicFields 

func (from *Grace) CopyBasicFields(to *Grace)

func (*Grace) GetName 

func (grace *Grace) GetName() (res string)

for satisfaction of GongStruct interface

func (*Grace) Stage 

func (grace *Grace) Stage(stage *StageStruct) *Grace

Stage puts grace to the model stage

func (*Grace) Unstage 

func (grace *Grace) Unstage(stage *StageStruct) *Grace

Unstage removes grace off the model stage

func (*Grace) UnstageVoid 

func (grace *Grace) UnstageVoid(stage *StageStruct)

UnstageVoid removes grace off the model stage

type Grace_WOP 

type Grace_WOP struct {
	// insertion point
	Name string
}

type Group_barline 

type Group_barline struct {
	Name  string
	Value *Group_barline_value `xml:",chardata" json:"-,"`
}

func CopyBranchGroup_barline 

func CopyBranchGroup_barline(mapOrigCopy map[any]any, group_barlineFrom *Group_barline) (group_barlineTo *Group_barline)

func (*Group_barline) Checkout 

func (group_barline *Group_barline) Checkout(stage *StageStruct) *Group_barline

Checkout group_barline to the back repo (if it is already staged)

func (*Group_barline) Commit 

func (group_barline *Group_barline) Commit(stage *StageStruct) *Group_barline

commit group_barline to the back repo (if it is already staged)

func (*Group_barline) CommitVoid 

func (group_barline *Group_barline) CommitVoid(stage *StageStruct)

func (*Group_barline) CopyBasicFields 

func (from *Group_barline) CopyBasicFields(to *Group_barline)

func (*Group_barline) GetName 

func (group_barline *Group_barline) GetName() (res string)

for satisfaction of GongStruct interface

func (*Group_barline) Stage 

func (group_barline *Group_barline) Stage(stage *StageStruct) *Group_barline

Stage puts group_barline to the model stage

func (*Group_barline) Unstage 

func (group_barline *Group_barline) Unstage(stage *StageStruct) *Group_barline

Unstage removes group_barline off the model stage

func (*Group_barline) UnstageVoid 

func (group_barline *Group_barline) UnstageVoid(stage *StageStruct)

UnstageVoid removes group_barline off the model stage

type Group_barline_WOP 

type Group_barline_WOP struct {
	// insertion point
	Name string
}

type Group_barline_value 

type Group_barline_value string
const (
	Group_barline_valueYes Group_barline_value = "yes"

	Group_barline_valueNo Group_barline_value = "no"

	Group_barline_valueMensurstrich Group_barline_value = "Mensurstrich"
)

func (Group_barline_value) CodeValues 

func (group_barline_value Group_barline_value) CodeValues() (res []string)

func (Group_barline_value) Codes 

func (group_barline_value Group_barline_value) Codes() (res []string)

func (*Group_barline_value) FromCodeString 

func (group_barline_value *Group_barline_value) FromCodeString(input string) (err error)

func (*Group_barline_value) FromString 

func (group_barline_value *Group_barline_value) FromString(input string) (err error)

func (*Group_barline_value) ToCodeString 

func (group_barline_value *Group_barline_value) ToCodeString() (res string)

func (Group_barline_value) ToString 

func (group_barline_value Group_barline_value) ToString() (res string)

Utility function for Group_barline_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Group_name 

type Group_name string

func (Group_name) CodeValues 

func (group_name Group_name) CodeValues() (res []string)

func (Group_name) Codes 

func (group_name Group_name) Codes() (res []string)

func (*Group_name) FromCodeString 

func (group_name *Group_name) FromCodeString(input string) (err error)

func (*Group_name) FromString 

func (group_name *Group_name) FromString(input string) (err error)

func (*Group_name) ToCodeString 

func (group_name *Group_name) ToCodeString() (res string)

func (Group_name) ToString 

func (group_name Group_name) ToString() (res string)

Utility function for Group_name if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Group_symbol 

type Group_symbol struct {
	Name  string
	Value *Group_symbol_value `xml:",chardata" json:"-,"`
}

func CopyBranchGroup_symbol 

func CopyBranchGroup_symbol(mapOrigCopy map[any]any, group_symbolFrom *Group_symbol) (group_symbolTo *Group_symbol)

func (*Group_symbol) Checkout 

func (group_symbol *Group_symbol) Checkout(stage *StageStruct) *Group_symbol

Checkout group_symbol to the back repo (if it is already staged)

func (*Group_symbol) Commit 

func (group_symbol *Group_symbol) Commit(stage *StageStruct) *Group_symbol

commit group_symbol to the back repo (if it is already staged)

func (*Group_symbol) CommitVoid 

func (group_symbol *Group_symbol) CommitVoid(stage *StageStruct)

func (*Group_symbol) CopyBasicFields 

func (from *Group_symbol) CopyBasicFields(to *Group_symbol)

func (*Group_symbol) GetName 

func (group_symbol *Group_symbol) GetName() (res string)

for satisfaction of GongStruct interface

func (*Group_symbol) Stage 

func (group_symbol *Group_symbol) Stage(stage *StageStruct) *Group_symbol

Stage puts group_symbol to the model stage

func (*Group_symbol) Unstage 

func (group_symbol *Group_symbol) Unstage(stage *StageStruct) *Group_symbol

Unstage removes group_symbol off the model stage

func (*Group_symbol) UnstageVoid 

func (group_symbol *Group_symbol) UnstageVoid(stage *StageStruct)

UnstageVoid removes group_symbol off the model stage

type Group_symbol_WOP 

type Group_symbol_WOP struct {
	// insertion point
	Name string
}

type Group_symbol_value 

type Group_symbol_value string
const (
	Group_symbol_valueNone Group_symbol_value = "none"

	Group_symbol_valueBrace Group_symbol_value = "brace"

	Group_symbol_valueLine Group_symbol_value = "line"

	Group_symbol_valueBracket Group_symbol_value = "bracket"

	Group_symbol_valueSquare Group_symbol_value = "square"
)

func (Group_symbol_value) CodeValues 

func (group_symbol_value Group_symbol_value) CodeValues() (res []string)

func (Group_symbol_value) Codes 

func (group_symbol_value Group_symbol_value) Codes() (res []string)

func (*Group_symbol_value) FromCodeString 

func (group_symbol_value *Group_symbol_value) FromCodeString(input string) (err error)

func (*Group_symbol_value) FromString 

func (group_symbol_value *Group_symbol_value) FromString(input string) (err error)

func (*Group_symbol_value) ToCodeString 

func (group_symbol_value *Group_symbol_value) ToCodeString() (res string)

func (Group_symbol_value) ToString 

func (group_symbol_value Group_symbol_value) ToString() (res string)

Utility function for Group_symbol_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Grouping 

type Grouping struct {
	Name    string
	Feature []*Feature `xml:"feature,omitempty" json:"feature,omitempty"`

	Type *Start_stop_single `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number string `xml:"number,attr,omitempty" json:"number,omitempty"`

	Member_of string `xml:"member-of,attr,omitempty" json:"member-of,omitempty"`
}

func CopyBranchGrouping 

func CopyBranchGrouping(mapOrigCopy map[any]any, groupingFrom *Grouping) (groupingTo *Grouping)

func (*Grouping) Checkout 

func (grouping *Grouping) Checkout(stage *StageStruct) *Grouping

Checkout grouping to the back repo (if it is already staged)

func (*Grouping) Commit 

func (grouping *Grouping) Commit(stage *StageStruct) *Grouping

commit grouping to the back repo (if it is already staged)

func (*Grouping) CommitVoid 

func (grouping *Grouping) CommitVoid(stage *StageStruct)

func (*Grouping) CopyBasicFields 

func (from *Grouping) CopyBasicFields(to *Grouping)

func (*Grouping) GetName 

func (grouping *Grouping) GetName() (res string)

for satisfaction of GongStruct interface

func (*Grouping) Stage 

func (grouping *Grouping) Stage(stage *StageStruct) *Grouping

Stage puts grouping to the model stage

func (*Grouping) Unstage 

func (grouping *Grouping) Unstage(stage *StageStruct) *Grouping

Unstage removes grouping off the model stage

func (*Grouping) UnstageVoid 

func (grouping *Grouping) UnstageVoid(stage *StageStruct)

UnstageVoid removes grouping off the model stage

type Grouping_WOP 

type Grouping_WOP struct {
	// insertion point
	Name      string
	Number    string
	Member_of string
}

type Hammer_on_pull_off 

type Hammer_on_pull_off struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchHammer_on_pull_off 

func CopyBranchHammer_on_pull_off(mapOrigCopy map[any]any, hammer_on_pull_offFrom *Hammer_on_pull_off) (hammer_on_pull_offTo *Hammer_on_pull_off)

func (*Hammer_on_pull_off) Checkout 

func (hammer_on_pull_off *Hammer_on_pull_off) Checkout(stage *StageStruct) *Hammer_on_pull_off

Checkout hammer_on_pull_off to the back repo (if it is already staged)

func (*Hammer_on_pull_off) Commit 

func (hammer_on_pull_off *Hammer_on_pull_off) Commit(stage *StageStruct) *Hammer_on_pull_off

commit hammer_on_pull_off to the back repo (if it is already staged)

func (*Hammer_on_pull_off) CommitVoid 

func (hammer_on_pull_off *Hammer_on_pull_off) CommitVoid(stage *StageStruct)

func (*Hammer_on_pull_off) CopyBasicFields 

func (from *Hammer_on_pull_off) CopyBasicFields(to *Hammer_on_pull_off)

func (*Hammer_on_pull_off) GetName 

func (hammer_on_pull_off *Hammer_on_pull_off) GetName() (res string)

for satisfaction of GongStruct interface

func (*Hammer_on_pull_off) Stage 

func (hammer_on_pull_off *Hammer_on_pull_off) Stage(stage *StageStruct) *Hammer_on_pull_off

Stage puts hammer_on_pull_off to the model stage

func (*Hammer_on_pull_off) Unstage 

func (hammer_on_pull_off *Hammer_on_pull_off) Unstage(stage *StageStruct) *Hammer_on_pull_off

Unstage removes hammer_on_pull_off off the model stage

func (*Hammer_on_pull_off) UnstageVoid 

func (hammer_on_pull_off *Hammer_on_pull_off) UnstageVoid(stage *StageStruct)

UnstageVoid removes hammer_on_pull_off off the model stage

type Hammer_on_pull_off_WOP 

type Hammer_on_pull_off_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Handbell 

type Handbell struct {
	Name  string
	Value *Handbell_value `xml:",chardata" json:"-,"`
}

func CopyBranchHandbell 

func CopyBranchHandbell(mapOrigCopy map[any]any, handbellFrom *Handbell) (handbellTo *Handbell)

func (*Handbell) Checkout 

func (handbell *Handbell) Checkout(stage *StageStruct) *Handbell

Checkout handbell to the back repo (if it is already staged)

func (*Handbell) Commit 

func (handbell *Handbell) Commit(stage *StageStruct) *Handbell

commit handbell to the back repo (if it is already staged)

func (*Handbell) CommitVoid 

func (handbell *Handbell) CommitVoid(stage *StageStruct)

func (*Handbell) CopyBasicFields 

func (from *Handbell) CopyBasicFields(to *Handbell)

func (*Handbell) GetName 

func (handbell *Handbell) GetName() (res string)

for satisfaction of GongStruct interface

func (*Handbell) Stage 

func (handbell *Handbell) Stage(stage *StageStruct) *Handbell

Stage puts handbell to the model stage

func (*Handbell) Unstage 

func (handbell *Handbell) Unstage(stage *StageStruct) *Handbell

Unstage removes handbell off the model stage

func (*Handbell) UnstageVoid 

func (handbell *Handbell) UnstageVoid(stage *StageStruct)

UnstageVoid removes handbell off the model stage

type Handbell_WOP 

type Handbell_WOP struct {
	// insertion point
	Name string
}

type Handbell_value 

type Handbell_value string
const (
	Handbell_valueBelltree Handbell_value = "belltree"

	Handbell_valueDamp Handbell_value = "damp"

	Handbell_valueEcho Handbell_value = "echo"

	Handbell_valueGyro Handbell_value = "gyro"

	Handbell_valueHandmartellato Handbell_value = "hand martellato"

	Handbell_valueMalletlift Handbell_value = "mallet lift"

	Handbell_valueMallettable Handbell_value = "mallet table"

	Handbell_valueMartellato Handbell_value = "martellato"

	Handbell_valueMartellatolift Handbell_value = "martellato lift"

	Handbell_valueMutedmartellato Handbell_value = "muted martellato"

	Handbell_valuePlucklift Handbell_value = "pluck lift"

	Handbell_valueSwing Handbell_value = "swing"
)

func (Handbell_value) CodeValues 

func (handbell_value Handbell_value) CodeValues() (res []string)

func (Handbell_value) Codes 

func (handbell_value Handbell_value) Codes() (res []string)

func (*Handbell_value) FromCodeString 

func (handbell_value *Handbell_value) FromCodeString(input string) (err error)

func (*Handbell_value) FromString 

func (handbell_value *Handbell_value) FromString(input string) (err error)

func (*Handbell_value) ToCodeString 

func (handbell_value *Handbell_value) ToCodeString() (res string)

func (Handbell_value) ToString 

func (handbell_value Handbell_value) ToString() (res string)

Utility function for Handbell_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Harmon_closed 

type Harmon_closed struct {
	Name  string
	Value *Harmon_closed_value `xml:",chardata" json:"-,"`

	Location *Harmon_closed_location `xml:"location,attr,omitempty" json:"location,omitempty"`
}

func CopyBranchHarmon_closed 

func CopyBranchHarmon_closed(mapOrigCopy map[any]any, harmon_closedFrom *Harmon_closed) (harmon_closedTo *Harmon_closed)

func (*Harmon_closed) Checkout 

func (harmon_closed *Harmon_closed) Checkout(stage *StageStruct) *Harmon_closed

Checkout harmon_closed to the back repo (if it is already staged)

func (*Harmon_closed) Commit 

func (harmon_closed *Harmon_closed) Commit(stage *StageStruct) *Harmon_closed

commit harmon_closed to the back repo (if it is already staged)

func (*Harmon_closed) CommitVoid 

func (harmon_closed *Harmon_closed) CommitVoid(stage *StageStruct)

func (*Harmon_closed) CopyBasicFields 

func (from *Harmon_closed) CopyBasicFields(to *Harmon_closed)

func (*Harmon_closed) GetName 

func (harmon_closed *Harmon_closed) GetName() (res string)

for satisfaction of GongStruct interface

func (*Harmon_closed) Stage 

func (harmon_closed *Harmon_closed) Stage(stage *StageStruct) *Harmon_closed

Stage puts harmon_closed to the model stage

func (*Harmon_closed) Unstage 

func (harmon_closed *Harmon_closed) Unstage(stage *StageStruct) *Harmon_closed

Unstage removes harmon_closed off the model stage

func (*Harmon_closed) UnstageVoid 

func (harmon_closed *Harmon_closed) UnstageVoid(stage *StageStruct)

UnstageVoid removes harmon_closed off the model stage

type Harmon_closed_WOP 

type Harmon_closed_WOP struct {
	// insertion point
	Name string
}

type Harmon_closed_location 

type Harmon_closed_location string
const (
	Harmon_closed_locationRight Harmon_closed_location = "right"

	Harmon_closed_locationBottom Harmon_closed_location = "bottom"

	Harmon_closed_locationLeft Harmon_closed_location = "left"

	Harmon_closed_locationTop Harmon_closed_location = "top"
)

func (Harmon_closed_location) CodeValues 

func (harmon_closed_location Harmon_closed_location) CodeValues() (res []string)

func (Harmon_closed_location) Codes 

func (harmon_closed_location Harmon_closed_location) Codes() (res []string)

func (*Harmon_closed_location) FromCodeString 

func (harmon_closed_location *Harmon_closed_location) FromCodeString(input string) (err error)

func (*Harmon_closed_location) FromString 

func (harmon_closed_location *Harmon_closed_location) FromString(input string) (err error)

func (*Harmon_closed_location) ToCodeString 

func (harmon_closed_location *Harmon_closed_location) ToCodeString() (res string)

func (Harmon_closed_location) ToString 

func (harmon_closed_location Harmon_closed_location) ToString() (res string)

Utility function for Harmon_closed_location if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Harmon_closed_value 

type Harmon_closed_value string
const (
	Harmon_closed_valueYes Harmon_closed_value = "yes"

	Harmon_closed_valueNo Harmon_closed_value = "no"

	Harmon_closed_valueHalf Harmon_closed_value = "half"
)

func (Harmon_closed_value) CodeValues 

func (harmon_closed_value Harmon_closed_value) CodeValues() (res []string)

func (Harmon_closed_value) Codes 

func (harmon_closed_value Harmon_closed_value) Codes() (res []string)

func (*Harmon_closed_value) FromCodeString 

func (harmon_closed_value *Harmon_closed_value) FromCodeString(input string) (err error)

func (*Harmon_closed_value) FromString 

func (harmon_closed_value *Harmon_closed_value) FromString(input string) (err error)

func (*Harmon_closed_value) ToCodeString 

func (harmon_closed_value *Harmon_closed_value) ToCodeString() (res string)

func (Harmon_closed_value) ToString 

func (harmon_closed_value Harmon_closed_value) ToString() (res string)

Utility function for Harmon_closed_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Harmon_mute 

type Harmon_mute struct {
	Name          string
	Harmon_closed *Harmon_closed `xml:"harmon-closed,omitempty" json:"harmon-closed,omitempty"`
}

func CopyBranchHarmon_mute 

func CopyBranchHarmon_mute(mapOrigCopy map[any]any, harmon_muteFrom *Harmon_mute) (harmon_muteTo *Harmon_mute)

func (*Harmon_mute) Checkout 

func (harmon_mute *Harmon_mute) Checkout(stage *StageStruct) *Harmon_mute

Checkout harmon_mute to the back repo (if it is already staged)

func (*Harmon_mute) Commit 

func (harmon_mute *Harmon_mute) Commit(stage *StageStruct) *Harmon_mute

commit harmon_mute to the back repo (if it is already staged)

func (*Harmon_mute) CommitVoid 

func (harmon_mute *Harmon_mute) CommitVoid(stage *StageStruct)

func (*Harmon_mute) CopyBasicFields 

func (from *Harmon_mute) CopyBasicFields(to *Harmon_mute)

func (*Harmon_mute) GetName 

func (harmon_mute *Harmon_mute) GetName() (res string)

for satisfaction of GongStruct interface

func (*Harmon_mute) Stage 

func (harmon_mute *Harmon_mute) Stage(stage *StageStruct) *Harmon_mute

Stage puts harmon_mute to the model stage

func (*Harmon_mute) Unstage 

func (harmon_mute *Harmon_mute) Unstage(stage *StageStruct) *Harmon_mute

Unstage removes harmon_mute off the model stage

func (*Harmon_mute) UnstageVoid 

func (harmon_mute *Harmon_mute) UnstageVoid(stage *StageStruct)

UnstageVoid removes harmon_mute off the model stage

type Harmon_mute_WOP 

type Harmon_mute_WOP struct {
	// insertion point
	Name string
}

type Harmonic 

type Harmonic struct {
	Name string

	// The natural element indicates that this is a natural
	// harmonic. These are usually notated at base pitch rather than sounding
	// pitch.
	Natural *Empty `xml:"natural,omitempty" json:"natural,omitempty"`

	// The artificial element indicates that this is an
	// artificial harmonic.
	Artificial *Empty `xml:"artificial,omitempty" json:"artificial,omitempty"`

	// The base pitch is the pitch at which the string is played
	// before touching to create the harmonic.
	Base_pitch *Empty `xml:"base-pitch,omitempty" json:"base-pitch,omitempty"`

	// The touching-pitch is the pitch at which the string is
	// touched lightly to produce the harmonic.
	Touching_pitch *Empty `xml:"touching-pitch,omitempty" json:"touching-pitch,omitempty"`

	// The sounding-pitch is the pitch which is heard when
	// playing the harmonic.
	Sounding_pitch *Empty `xml:"sounding-pitch,omitempty" json:"sounding-pitch,omitempty"`
}

func CopyBranchHarmonic 

func CopyBranchHarmonic(mapOrigCopy map[any]any, harmonicFrom *Harmonic) (harmonicTo *Harmonic)

func (*Harmonic) Checkout 

func (harmonic *Harmonic) Checkout(stage *StageStruct) *Harmonic

Checkout harmonic to the back repo (if it is already staged)

func (*Harmonic) Commit 

func (harmonic *Harmonic) Commit(stage *StageStruct) *Harmonic

commit harmonic to the back repo (if it is already staged)

func (*Harmonic) CommitVoid 

func (harmonic *Harmonic) CommitVoid(stage *StageStruct)

func (*Harmonic) CopyBasicFields 

func (from *Harmonic) CopyBasicFields(to *Harmonic)

func (*Harmonic) GetName 

func (harmonic *Harmonic) GetName() (res string)

for satisfaction of GongStruct interface

func (*Harmonic) Stage 

func (harmonic *Harmonic) Stage(stage *StageStruct) *Harmonic

Stage puts harmonic to the model stage

func (*Harmonic) Unstage 

func (harmonic *Harmonic) Unstage(stage *StageStruct) *Harmonic

Unstage removes harmonic off the model stage

func (*Harmonic) UnstageVoid 

func (harmonic *Harmonic) UnstageVoid(stage *StageStruct)

UnstageVoid removes harmonic off the model stage

type Harmonic_WOP 

type Harmonic_WOP struct {
	// insertion point
	Name string
}

type Harmony 

type Harmony struct {
	Name  string
	Frame *Frame `xml:"frame,omitempty" json:"frame,omitempty"`

	Offset *Offset `xml:"offset,omitempty" json:"offset,omitempty"`

	Type *Harmony_type `xml:"type,attr,omitempty" json:"type,omitempty"`

	Print_frame *Yes_no `xml:"print-frame,attr,omitempty" json:"print-frame,omitempty"`

	Arrangement *Harmony_arrangement `xml:"arrangement,attr,omitempty" json:"arrangement,omitempty"`
}

func CopyBranchHarmony 

func CopyBranchHarmony(mapOrigCopy map[any]any, harmonyFrom *Harmony) (harmonyTo *Harmony)

func (*Harmony) Checkout 

func (harmony *Harmony) Checkout(stage *StageStruct) *Harmony

Checkout harmony to the back repo (if it is already staged)

func (*Harmony) Commit 

func (harmony *Harmony) Commit(stage *StageStruct) *Harmony

commit harmony to the back repo (if it is already staged)

func (*Harmony) CommitVoid 

func (harmony *Harmony) CommitVoid(stage *StageStruct)

func (*Harmony) CopyBasicFields 

func (from *Harmony) CopyBasicFields(to *Harmony)

func (*Harmony) GetName 

func (harmony *Harmony) GetName() (res string)

for satisfaction of GongStruct interface

func (*Harmony) Stage 

func (harmony *Harmony) Stage(stage *StageStruct) *Harmony

Stage puts harmony to the model stage

func (*Harmony) Unstage 

func (harmony *Harmony) Unstage(stage *StageStruct) *Harmony

Unstage removes harmony off the model stage

func (*Harmony) UnstageVoid 

func (harmony *Harmony) UnstageVoid(stage *StageStruct)

UnstageVoid removes harmony off the model stage

type Harmony_WOP 

type Harmony_WOP struct {
	// insertion point
	Name string
}

type Harmony_alter 

type Harmony_alter struct {
	Name  string
	Value *Semitones `xml:",chardata" json:"-,"`

	Location *Left_right `xml:"location,attr,omitempty" json:"location,omitempty"`
}

func CopyBranchHarmony_alter 

func CopyBranchHarmony_alter(mapOrigCopy map[any]any, harmony_alterFrom *Harmony_alter) (harmony_alterTo *Harmony_alter)

func (*Harmony_alter) Checkout 

func (harmony_alter *Harmony_alter) Checkout(stage *StageStruct) *Harmony_alter

Checkout harmony_alter to the back repo (if it is already staged)

func (*Harmony_alter) Commit 

func (harmony_alter *Harmony_alter) Commit(stage *StageStruct) *Harmony_alter

commit harmony_alter to the back repo (if it is already staged)

func (*Harmony_alter) CommitVoid 

func (harmony_alter *Harmony_alter) CommitVoid(stage *StageStruct)

func (*Harmony_alter) CopyBasicFields 

func (from *Harmony_alter) CopyBasicFields(to *Harmony_alter)

func (*Harmony_alter) GetName 

func (harmony_alter *Harmony_alter) GetName() (res string)

for satisfaction of GongStruct interface

func (*Harmony_alter) Stage 

func (harmony_alter *Harmony_alter) Stage(stage *StageStruct) *Harmony_alter

Stage puts harmony_alter to the model stage

func (*Harmony_alter) Unstage 

func (harmony_alter *Harmony_alter) Unstage(stage *StageStruct) *Harmony_alter

Unstage removes harmony_alter off the model stage

func (*Harmony_alter) UnstageVoid 

func (harmony_alter *Harmony_alter) UnstageVoid(stage *StageStruct)

UnstageVoid removes harmony_alter off the model stage

type Harmony_alter_WOP 

type Harmony_alter_WOP struct {
	// insertion point
	Name string
}

type Harmony_arrangement 

type Harmony_arrangement string
const (
	Harmony_arrangementVertical Harmony_arrangement = "vertical"

	Harmony_arrangementHorizontal Harmony_arrangement = "horizontal"

	Harmony_arrangementDiagonal Harmony_arrangement = "diagonal"
)

func (Harmony_arrangement) CodeValues 

func (harmony_arrangement Harmony_arrangement) CodeValues() (res []string)

func (Harmony_arrangement) Codes 

func (harmony_arrangement Harmony_arrangement) Codes() (res []string)

func (*Harmony_arrangement) FromCodeString 

func (harmony_arrangement *Harmony_arrangement) FromCodeString(input string) (err error)

func (*Harmony_arrangement) FromString 

func (harmony_arrangement *Harmony_arrangement) FromString(input string) (err error)

func (*Harmony_arrangement) ToCodeString 

func (harmony_arrangement *Harmony_arrangement) ToCodeString() (res string)

func (Harmony_arrangement) ToString 

func (harmony_arrangement Harmony_arrangement) ToString() (res string)

Utility function for Harmony_arrangement if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Harmony_type 

type Harmony_type string
const (
	Harmony_typeExplicit Harmony_type = "explicit"

	Harmony_typeImplied Harmony_type = "implied"

	Harmony_typeAlternate Harmony_type = "alternate"
)

func (Harmony_type) CodeValues 

func (harmony_type Harmony_type) CodeValues() (res []string)

func (Harmony_type) Codes 

func (harmony_type Harmony_type) Codes() (res []string)

func (*Harmony_type) FromCodeString 

func (harmony_type *Harmony_type) FromCodeString(input string) (err error)

func (*Harmony_type) FromString 

func (harmony_type *Harmony_type) FromString(input string) (err error)

func (*Harmony_type) ToCodeString 

func (harmony_type *Harmony_type) ToCodeString() (res string)

func (Harmony_type) ToString 

func (harmony_type Harmony_type) ToString() (res string)

Utility function for Harmony_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Harp_pedals 

type Harp_pedals struct {
	Name         string
	Pedal_tuning []*Pedal_tuning `xml:"pedal-tuning,omitempty" json:"pedal-tuning,omitempty"`
}

func CopyBranchHarp_pedals 

func CopyBranchHarp_pedals(mapOrigCopy map[any]any, harp_pedalsFrom *Harp_pedals) (harp_pedalsTo *Harp_pedals)

func (*Harp_pedals) Checkout 

func (harp_pedals *Harp_pedals) Checkout(stage *StageStruct) *Harp_pedals

Checkout harp_pedals to the back repo (if it is already staged)

func (*Harp_pedals) Commit 

func (harp_pedals *Harp_pedals) Commit(stage *StageStruct) *Harp_pedals

commit harp_pedals to the back repo (if it is already staged)

func (*Harp_pedals) CommitVoid 

func (harp_pedals *Harp_pedals) CommitVoid(stage *StageStruct)

func (*Harp_pedals) CopyBasicFields 

func (from *Harp_pedals) CopyBasicFields(to *Harp_pedals)

func (*Harp_pedals) GetName 

func (harp_pedals *Harp_pedals) GetName() (res string)

for satisfaction of GongStruct interface

func (*Harp_pedals) Stage 

func (harp_pedals *Harp_pedals) Stage(stage *StageStruct) *Harp_pedals

Stage puts harp_pedals to the model stage

func (*Harp_pedals) Unstage 

func (harp_pedals *Harp_pedals) Unstage(stage *StageStruct) *Harp_pedals

Unstage removes harp_pedals off the model stage

func (*Harp_pedals) UnstageVoid 

func (harp_pedals *Harp_pedals) UnstageVoid(stage *StageStruct)

UnstageVoid removes harp_pedals off the model stage

type Harp_pedals_WOP 

type Harp_pedals_WOP struct {
	// insertion point
	Name string
}

type Heel_toe 

type Heel_toe struct {
	Name string
	*Empty_placement

	Substitution *Yes_no `xml:"substitution,attr,omitempty" json:"substitution,omitempty"`
}

func CopyBranchHeel_toe 

func CopyBranchHeel_toe(mapOrigCopy map[any]any, heel_toeFrom *Heel_toe) (heel_toeTo *Heel_toe)

func (*Heel_toe) Checkout 

func (heel_toe *Heel_toe) Checkout(stage *StageStruct) *Heel_toe

Checkout heel_toe to the back repo (if it is already staged)

func (*Heel_toe) Commit 

func (heel_toe *Heel_toe) Commit(stage *StageStruct) *Heel_toe

commit heel_toe to the back repo (if it is already staged)

func (*Heel_toe) CommitVoid 

func (heel_toe *Heel_toe) CommitVoid(stage *StageStruct)

func (*Heel_toe) CopyBasicFields 

func (from *Heel_toe) CopyBasicFields(to *Heel_toe)

func (*Heel_toe) GetName 

func (heel_toe *Heel_toe) GetName() (res string)

for satisfaction of GongStruct interface

func (*Heel_toe) Stage 

func (heel_toe *Heel_toe) Stage(stage *StageStruct) *Heel_toe

Stage puts heel_toe to the model stage

func (*Heel_toe) Unstage 

func (heel_toe *Heel_toe) Unstage(stage *StageStruct) *Heel_toe

Unstage removes heel_toe off the model stage

func (*Heel_toe) UnstageVoid 

func (heel_toe *Heel_toe) UnstageVoid(stage *StageStruct)

UnstageVoid removes heel_toe off the model stage

type Heel_toe_WOP 

type Heel_toe_WOP struct {
	// insertion point
	Name string
}

type Hole 

type Hole struct {
	Name string

	// The content of the optional hole-type element indicates what
	// the hole symbol represents in terms of instrument fingering or other
	// techniques.
	Hole_type string `xml:"hole-type,omitempty" json:"hole-type,omitempty"`

	Hole_closed *Hole_closed `xml:"hole-closed,omitempty" json:"hole-closed,omitempty"`

	// The optional hole-shape element indicates the shape of the
	// hole symbol; the default is a circle.
	Hole_shape string `xml:"hole-shape,omitempty" json:"hole-shape,omitempty"`
}

func CopyBranchHole 

func CopyBranchHole(mapOrigCopy map[any]any, holeFrom *Hole) (holeTo *Hole)

func (*Hole) Checkout 

func (hole *Hole) Checkout(stage *StageStruct) *Hole

Checkout hole to the back repo (if it is already staged)

func (*Hole) Commit 

func (hole *Hole) Commit(stage *StageStruct) *Hole

commit hole to the back repo (if it is already staged)

func (*Hole) CommitVoid 

func (hole *Hole) CommitVoid(stage *StageStruct)

func (*Hole) CopyBasicFields 

func (from *Hole) CopyBasicFields(to *Hole)

func (*Hole) GetName 

func (hole *Hole) GetName() (res string)

for satisfaction of GongStruct interface

func (*Hole) Stage 

func (hole *Hole) Stage(stage *StageStruct) *Hole

Stage puts hole to the model stage

func (*Hole) Unstage 

func (hole *Hole) Unstage(stage *StageStruct) *Hole

Unstage removes hole off the model stage

func (*Hole) UnstageVoid 

func (hole *Hole) UnstageVoid(stage *StageStruct)

UnstageVoid removes hole off the model stage

type Hole_WOP 

type Hole_WOP struct {
	// insertion point
	Name       string
	Hole_type  string
	Hole_shape string
}

type Hole_closed 

type Hole_closed struct {
	Name  string
	Value *Hole_closed_value `xml:",chardata" json:"-,"`

	Location *Hole_closed_location `xml:"location,attr,omitempty" json:"location,omitempty"`
}

func CopyBranchHole_closed 

func CopyBranchHole_closed(mapOrigCopy map[any]any, hole_closedFrom *Hole_closed) (hole_closedTo *Hole_closed)

func (*Hole_closed) Checkout 

func (hole_closed *Hole_closed) Checkout(stage *StageStruct) *Hole_closed

Checkout hole_closed to the back repo (if it is already staged)

func (*Hole_closed) Commit 

func (hole_closed *Hole_closed) Commit(stage *StageStruct) *Hole_closed

commit hole_closed to the back repo (if it is already staged)

func (*Hole_closed) CommitVoid 

func (hole_closed *Hole_closed) CommitVoid(stage *StageStruct)

func (*Hole_closed) CopyBasicFields 

func (from *Hole_closed) CopyBasicFields(to *Hole_closed)

func (*Hole_closed) GetName 

func (hole_closed *Hole_closed) GetName() (res string)

for satisfaction of GongStruct interface

func (*Hole_closed) Stage 

func (hole_closed *Hole_closed) Stage(stage *StageStruct) *Hole_closed

Stage puts hole_closed to the model stage

func (*Hole_closed) Unstage 

func (hole_closed *Hole_closed) Unstage(stage *StageStruct) *Hole_closed

Unstage removes hole_closed off the model stage

func (*Hole_closed) UnstageVoid 

func (hole_closed *Hole_closed) UnstageVoid(stage *StageStruct)

UnstageVoid removes hole_closed off the model stage

type Hole_closed_WOP 

type Hole_closed_WOP struct {
	// insertion point
	Name string
}

type Hole_closed_location 

type Hole_closed_location string
const (
	Hole_closed_locationRight Hole_closed_location = "right"

	Hole_closed_locationBottom Hole_closed_location = "bottom"

	Hole_closed_locationLeft Hole_closed_location = "left"

	Hole_closed_locationTop Hole_closed_location = "top"
)

func (Hole_closed_location) CodeValues 

func (hole_closed_location Hole_closed_location) CodeValues() (res []string)

func (Hole_closed_location) Codes 

func (hole_closed_location Hole_closed_location) Codes() (res []string)

func (*Hole_closed_location) FromCodeString 

func (hole_closed_location *Hole_closed_location) FromCodeString(input string) (err error)

func (*Hole_closed_location) FromString 

func (hole_closed_location *Hole_closed_location) FromString(input string) (err error)

func (*Hole_closed_location) ToCodeString 

func (hole_closed_location *Hole_closed_location) ToCodeString() (res string)

func (Hole_closed_location) ToString 

func (hole_closed_location Hole_closed_location) ToString() (res string)

Utility function for Hole_closed_location if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Hole_closed_value 

type Hole_closed_value string
const (
	Hole_closed_valueYes Hole_closed_value = "yes"

	Hole_closed_valueNo Hole_closed_value = "no"

	Hole_closed_valueHalf Hole_closed_value = "half"
)

func (Hole_closed_value) CodeValues 

func (hole_closed_value Hole_closed_value) CodeValues() (res []string)

func (Hole_closed_value) Codes 

func (hole_closed_value Hole_closed_value) Codes() (res []string)

func (*Hole_closed_value) FromCodeString 

func (hole_closed_value *Hole_closed_value) FromCodeString(input string) (err error)

func (*Hole_closed_value) FromString 

func (hole_closed_value *Hole_closed_value) FromString(input string) (err error)

func (*Hole_closed_value) ToCodeString 

func (hole_closed_value *Hole_closed_value) ToCodeString() (res string)

func (Hole_closed_value) ToString 

func (hole_closed_value Hole_closed_value) ToString() (res string)

Utility function for Hole_closed_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Horizontal_turn 

type Horizontal_turn struct {
	Name  string
	Slash *Yes_no `xml:"slash,attr,omitempty" json:"slash,omitempty"`
}

func CopyBranchHorizontal_turn 

func CopyBranchHorizontal_turn(mapOrigCopy map[any]any, horizontal_turnFrom *Horizontal_turn) (horizontal_turnTo *Horizontal_turn)

func (*Horizontal_turn) Checkout 

func (horizontal_turn *Horizontal_turn) Checkout(stage *StageStruct) *Horizontal_turn

Checkout horizontal_turn to the back repo (if it is already staged)

func (*Horizontal_turn) Commit 

func (horizontal_turn *Horizontal_turn) Commit(stage *StageStruct) *Horizontal_turn

commit horizontal_turn to the back repo (if it is already staged)

func (*Horizontal_turn) CommitVoid 

func (horizontal_turn *Horizontal_turn) CommitVoid(stage *StageStruct)

func (*Horizontal_turn) CopyBasicFields 

func (from *Horizontal_turn) CopyBasicFields(to *Horizontal_turn)

func (*Horizontal_turn) GetName 

func (horizontal_turn *Horizontal_turn) GetName() (res string)

for satisfaction of GongStruct interface

func (*Horizontal_turn) Stage 

func (horizontal_turn *Horizontal_turn) Stage(stage *StageStruct) *Horizontal_turn

Stage puts horizontal_turn to the model stage

func (*Horizontal_turn) Unstage 

func (horizontal_turn *Horizontal_turn) Unstage(stage *StageStruct) *Horizontal_turn

Unstage removes horizontal_turn off the model stage

func (*Horizontal_turn) UnstageVoid 

func (horizontal_turn *Horizontal_turn) UnstageVoid(stage *StageStruct)

UnstageVoid removes horizontal_turn off the model stage

type Horizontal_turn_WOP 

type Horizontal_turn_WOP struct {
	// insertion point
	Name string
}

type IDREF 

type IDREF string

func (IDREF) CodeValues 

func (idref IDREF) CodeValues() (res []string)

func (IDREF) Codes 

func (idref IDREF) Codes() (res []string)

func (*IDREF) FromCodeString 

func (idref *IDREF) FromCodeString(input string) (err error)

func (*IDREF) FromString 

func (idref *IDREF) FromString(input string) (err error)

func (*IDREF) ToCodeString 

func (idref *IDREF) ToCodeString() (res string)

func (IDREF) ToString 

func (idref IDREF) ToString() (res string)

Utility function for IDREF if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type ID_MUSICXML 

type ID_MUSICXML string

func (ID_MUSICXML) CodeValues 

func (id_musicxml ID_MUSICXML) CodeValues() (res []string)

func (ID_MUSICXML) Codes 

func (id_musicxml ID_MUSICXML) Codes() (res []string)

func (*ID_MUSICXML) FromCodeString 

func (id_musicxml *ID_MUSICXML) FromCodeString(input string) (err error)

func (*ID_MUSICXML) FromString 

func (id_musicxml *ID_MUSICXML) FromString(input string) (err error)

func (*ID_MUSICXML) ToCodeString 

func (id_musicxml *ID_MUSICXML) ToCodeString() (res string)

func (ID_MUSICXML) ToString 

func (id_musicxml ID_MUSICXML) ToString() (res string)

Utility function for ID_MUSICXML if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Identification 

type Identification struct {
	Name string

	// The creator element is borrowed from Dublin Core. It is used
	// for the creators of the score. The type attribute is used to distinguish
	// different creative contributions. Thus, there can be multiple creators
	// within an identification. Standard type values are composer, lyricist, and
	// arranger. Other type values may be used for different types of creative
	// roles. The type attribute should usually be used even if there is just a
	// single creator element. The MusicXML format does not use the creator /
	// contributor distinction from Dublin Core.
	Creator []*Typed_text `xml:"creator,omitempty" json:"creator,omitempty"`

	// The rights element is borrowed from Dublin Core. It contains
	// copyright and other intellectual property notices. Words, music, and
	// derivatives can have different types, so multiple rights elements with
	// different type attributes are supported. Standard type values are music,
	// words, and arrangement, but other types may be used. The type attribute is
	// only needed when there are multiple rights elements.
	Rights []*Typed_text `xml:"rights,omitempty" json:"rights,omitempty"`

	Encoding *Encoding `xml:"encoding,omitempty" json:"encoding,omitempty"`

	// The source for the music that is encoded. This is similar to
	// the Dublin Core source element.
	Source string `xml:"source,omitempty" json:"source,omitempty"`

	// A related resource for the music that is encoded. This is
	// similar to the Dublin Core relation element. Standard type values are music,
	// words, and arrangement, but other types may be used.
	Relation []*Typed_text `xml:"relation,omitempty" json:"relation,omitempty"`

	Miscellaneous *Miscellaneous `xml:"miscellaneous,omitempty" json:"miscellaneous,omitempty"`
}

func CopyBranchIdentification 

func CopyBranchIdentification(mapOrigCopy map[any]any, identificationFrom *Identification) (identificationTo *Identification)

func (*Identification) Checkout 

func (identification *Identification) Checkout(stage *StageStruct) *Identification

Checkout identification to the back repo (if it is already staged)

func (*Identification) Commit 

func (identification *Identification) Commit(stage *StageStruct) *Identification

commit identification to the back repo (if it is already staged)

func (*Identification) CommitVoid 

func (identification *Identification) CommitVoid(stage *StageStruct)

func (*Identification) CopyBasicFields 

func (from *Identification) CopyBasicFields(to *Identification)

func (*Identification) GetName 

func (identification *Identification) GetName() (res string)

for satisfaction of GongStruct interface

func (*Identification) Stage 

func (identification *Identification) Stage(stage *StageStruct) *Identification

Stage puts identification to the model stage

func (*Identification) Unstage 

func (identification *Identification) Unstage(stage *StageStruct) *Identification

Unstage removes identification off the model stage

func (*Identification) UnstageVoid 

func (identification *Identification) UnstageVoid(stage *StageStruct)

UnstageVoid removes identification off the model stage

type Identification_WOP 

type Identification_WOP struct {
	// insertion point
	Name   string
	Source string
}

type Image 

type Image struct {
	Name string
}

func CopyBranchImage 

func CopyBranchImage(mapOrigCopy map[any]any, imageFrom *Image) (imageTo *Image)

func (*Image) Checkout 

func (image *Image) Checkout(stage *StageStruct) *Image

Checkout image to the back repo (if it is already staged)

func (*Image) Commit 

func (image *Image) Commit(stage *StageStruct) *Image

commit image to the back repo (if it is already staged)

func (*Image) CommitVoid 

func (image *Image) CommitVoid(stage *StageStruct)

func (*Image) CopyBasicFields 

func (from *Image) CopyBasicFields(to *Image)

func (*Image) GetName 

func (image *Image) GetName() (res string)

for satisfaction of GongStruct interface

func (*Image) Stage 

func (image *Image) Stage(stage *StageStruct) *Image

Stage puts image to the model stage

func (*Image) Unstage 

func (image *Image) Unstage(stage *StageStruct) *Image

Unstage removes image off the model stage

func (*Image) UnstageVoid 

func (image *Image) UnstageVoid(stage *StageStruct)

UnstageVoid removes image off the model stage

type Image_WOP 

type Image_WOP struct {
	// insertion point
	Name string
}

type Instrument 

type Instrument struct {
	Name string
	Id   *IDREF `xml:"id,attr,omitempty" json:"id,omitempty"`
}

func CopyBranchInstrument 

func CopyBranchInstrument(mapOrigCopy map[any]any, instrumentFrom *Instrument) (instrumentTo *Instrument)

func (*Instrument) Checkout 

func (instrument *Instrument) Checkout(stage *StageStruct) *Instrument

Checkout instrument to the back repo (if it is already staged)

func (*Instrument) Commit 

func (instrument *Instrument) Commit(stage *StageStruct) *Instrument

commit instrument to the back repo (if it is already staged)

func (*Instrument) CommitVoid 

func (instrument *Instrument) CommitVoid(stage *StageStruct)

func (*Instrument) CopyBasicFields 

func (from *Instrument) CopyBasicFields(to *Instrument)

func (*Instrument) GetName 

func (instrument *Instrument) GetName() (res string)

for satisfaction of GongStruct interface

func (*Instrument) Stage 

func (instrument *Instrument) Stage(stage *StageStruct) *Instrument

Stage puts instrument to the model stage

func (*Instrument) Unstage 

func (instrument *Instrument) Unstage(stage *StageStruct) *Instrument

Unstage removes instrument off the model stage

func (*Instrument) UnstageVoid 

func (instrument *Instrument) UnstageVoid(stage *StageStruct)

UnstageVoid removes instrument off the model stage

type Instrument_WOP 

type Instrument_WOP struct {
	// insertion point
	Name string
}

type Instrument_change 

type Instrument_change struct {
	Name string
	Id   *IDREF `xml:"id,attr,omitempty" json:"id,omitempty"`
}

func CopyBranchInstrument_change 

func CopyBranchInstrument_change(mapOrigCopy map[any]any, instrument_changeFrom *Instrument_change) (instrument_changeTo *Instrument_change)

func (*Instrument_change) Checkout 

func (instrument_change *Instrument_change) Checkout(stage *StageStruct) *Instrument_change

Checkout instrument_change to the back repo (if it is already staged)

func (*Instrument_change) Commit 

func (instrument_change *Instrument_change) Commit(stage *StageStruct) *Instrument_change

commit instrument_change to the back repo (if it is already staged)

func (*Instrument_change) CommitVoid 

func (instrument_change *Instrument_change) CommitVoid(stage *StageStruct)

func (*Instrument_change) CopyBasicFields 

func (from *Instrument_change) CopyBasicFields(to *Instrument_change)

func (*Instrument_change) GetName 

func (instrument_change *Instrument_change) GetName() (res string)

for satisfaction of GongStruct interface

func (*Instrument_change) Stage 

func (instrument_change *Instrument_change) Stage(stage *StageStruct) *Instrument_change

Stage puts instrument_change to the model stage

func (*Instrument_change) Unstage 

func (instrument_change *Instrument_change) Unstage(stage *StageStruct) *Instrument_change

Unstage removes instrument_change off the model stage

func (*Instrument_change) UnstageVoid 

func (instrument_change *Instrument_change) UnstageVoid(stage *StageStruct)

UnstageVoid removes instrument_change off the model stage

type Instrument_change_WOP 

type Instrument_change_WOP struct {
	// insertion point
	Name string
}
type Instrument_link struct {
	Name string
	Id   *IDREF `xml:"id,attr,omitempty" json:"id,omitempty"`
}
func CopyBranchInstrument_link(mapOrigCopy map[any]any, instrument_linkFrom *Instrument_link) (instrument_linkTo *Instrument_link)

func (*Instrument_link) Checkout 

func (instrument_link *Instrument_link) Checkout(stage *StageStruct) *Instrument_link

Checkout instrument_link to the back repo (if it is already staged)

func (*Instrument_link) Commit 

func (instrument_link *Instrument_link) Commit(stage *StageStruct) *Instrument_link

commit instrument_link to the back repo (if it is already staged)

func (*Instrument_link) CommitVoid 

func (instrument_link *Instrument_link) CommitVoid(stage *StageStruct)

func (*Instrument_link) CopyBasicFields 

func (from *Instrument_link) CopyBasicFields(to *Instrument_link)

func (*Instrument_link) GetName 

func (instrument_link *Instrument_link) GetName() (res string)

for satisfaction of GongStruct interface

func (*Instrument_link) Stage 

func (instrument_link *Instrument_link) Stage(stage *StageStruct) *Instrument_link

Stage puts instrument_link to the model stage

func (*Instrument_link) Unstage 

func (instrument_link *Instrument_link) Unstage(stage *StageStruct) *Instrument_link

Unstage removes instrument_link off the model stage

func (*Instrument_link) UnstageVoid 

func (instrument_link *Instrument_link) UnstageVoid(stage *StageStruct)

UnstageVoid removes instrument_link off the model stage 

type Instrument_link_WOP struct {
	// insertion point
	Name string
}

type Interchangeable 

type Interchangeable struct {
	Name          string
	Time_relation *Time_relation `xml:"time-relation,omitempty" json:"time-relation,omitempty"`

	Symbol *Time_symbol `xml:"symbol,attr,omitempty" json:"symbol,omitempty"`

	Separator *Time_separator `xml:"separator,attr,omitempty" json:"separator,omitempty"`
}

func CopyBranchInterchangeable 

func CopyBranchInterchangeable(mapOrigCopy map[any]any, interchangeableFrom *Interchangeable) (interchangeableTo *Interchangeable)

func (*Interchangeable) Checkout 

func (interchangeable *Interchangeable) Checkout(stage *StageStruct) *Interchangeable

Checkout interchangeable to the back repo (if it is already staged)

func (*Interchangeable) Commit 

func (interchangeable *Interchangeable) Commit(stage *StageStruct) *Interchangeable

commit interchangeable to the back repo (if it is already staged)

func (*Interchangeable) CommitVoid 

func (interchangeable *Interchangeable) CommitVoid(stage *StageStruct)

func (*Interchangeable) CopyBasicFields 

func (from *Interchangeable) CopyBasicFields(to *Interchangeable)

func (*Interchangeable) GetName 

func (interchangeable *Interchangeable) GetName() (res string)

for satisfaction of GongStruct interface

func (*Interchangeable) Stage 

func (interchangeable *Interchangeable) Stage(stage *StageStruct) *Interchangeable

Stage puts interchangeable to the model stage

func (*Interchangeable) Unstage 

func (interchangeable *Interchangeable) Unstage(stage *StageStruct) *Interchangeable

Unstage removes interchangeable off the model stage

func (*Interchangeable) UnstageVoid 

func (interchangeable *Interchangeable) UnstageVoid(stage *StageStruct)

UnstageVoid removes interchangeable off the model stage

type Interchangeable_WOP 

type Interchangeable_WOP struct {
	// insertion point
	Name string
}

type Inversion 

type Inversion struct {
	Name  string
	Value uint32 `xml:",chardata" json:"-,"`

	Text string `xml:"text,attr,omitempty" json:"text,omitempty"`
}

func CopyBranchInversion 

func CopyBranchInversion(mapOrigCopy map[any]any, inversionFrom *Inversion) (inversionTo *Inversion)

func (*Inversion) Checkout 

func (inversion *Inversion) Checkout(stage *StageStruct) *Inversion

Checkout inversion to the back repo (if it is already staged)

func (*Inversion) Commit 

func (inversion *Inversion) Commit(stage *StageStruct) *Inversion

commit inversion to the back repo (if it is already staged)

func (*Inversion) CommitVoid 

func (inversion *Inversion) CommitVoid(stage *StageStruct)

func (*Inversion) CopyBasicFields 

func (from *Inversion) CopyBasicFields(to *Inversion)

func (*Inversion) GetName 

func (inversion *Inversion) GetName() (res string)

for satisfaction of GongStruct interface

func (*Inversion) Stage 

func (inversion *Inversion) Stage(stage *StageStruct) *Inversion

Stage puts inversion to the model stage

func (*Inversion) Unstage 

func (inversion *Inversion) Unstage(stage *StageStruct) *Inversion

Unstage removes inversion off the model stage

func (*Inversion) UnstageVoid 

func (inversion *Inversion) UnstageVoid(stage *StageStruct)

UnstageVoid removes inversion off the model stage

type Inversion_WOP 

type Inversion_WOP struct {
	// insertion point
	Name string
	Text string
}

type Key 

type Key struct {
	Name string

	// The optional list of key-octave elements is used to specify in
	// which octave each element of the key signature appears.
	Key_octave []*Key_octave `xml:"key-octave,omitempty" json:"key-octave,omitempty"`

	Number *Staff_number `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchKey 

func CopyBranchKey(mapOrigCopy map[any]any, keyFrom *Key) (keyTo *Key)

func (*Key) Checkout 

func (key *Key) Checkout(stage *StageStruct) *Key

Checkout key to the back repo (if it is already staged)

func (*Key) Commit 

func (key *Key) Commit(stage *StageStruct) *Key

commit key to the back repo (if it is already staged)

func (*Key) CommitVoid 

func (key *Key) CommitVoid(stage *StageStruct)

func (*Key) CopyBasicFields 

func (from *Key) CopyBasicFields(to *Key)

func (*Key) GetName 

func (key *Key) GetName() (res string)

for satisfaction of GongStruct interface

func (*Key) Stage 

func (key *Key) Stage(stage *StageStruct) *Key

Stage puts key to the model stage

func (*Key) Unstage 

func (key *Key) Unstage(stage *StageStruct) *Key

Unstage removes key off the model stage

func (*Key) UnstageVoid 

func (key *Key) UnstageVoid(stage *StageStruct)

UnstageVoid removes key off the model stage

type Key_WOP 

type Key_WOP struct {
	// insertion point
	Name string
}

type Key_accidental 

type Key_accidental struct {
	Name  string
	Value *Accidental_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_accidental_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchKey_accidental 

func CopyBranchKey_accidental(mapOrigCopy map[any]any, key_accidentalFrom *Key_accidental) (key_accidentalTo *Key_accidental)

func (*Key_accidental) Checkout 

func (key_accidental *Key_accidental) Checkout(stage *StageStruct) *Key_accidental

Checkout key_accidental to the back repo (if it is already staged)

func (*Key_accidental) Commit 

func (key_accidental *Key_accidental) Commit(stage *StageStruct) *Key_accidental

commit key_accidental to the back repo (if it is already staged)

func (*Key_accidental) CommitVoid 

func (key_accidental *Key_accidental) CommitVoid(stage *StageStruct)

func (*Key_accidental) CopyBasicFields 

func (from *Key_accidental) CopyBasicFields(to *Key_accidental)

func (*Key_accidental) GetName 

func (key_accidental *Key_accidental) GetName() (res string)

for satisfaction of GongStruct interface

func (*Key_accidental) Stage 

func (key_accidental *Key_accidental) Stage(stage *StageStruct) *Key_accidental

Stage puts key_accidental to the model stage

func (*Key_accidental) Unstage 

func (key_accidental *Key_accidental) Unstage(stage *StageStruct) *Key_accidental

Unstage removes key_accidental off the model stage

func (*Key_accidental) UnstageVoid 

func (key_accidental *Key_accidental) UnstageVoid(stage *StageStruct)

UnstageVoid removes key_accidental off the model stage

type Key_accidental_WOP 

type Key_accidental_WOP struct {
	// insertion point
	Name string
}

type Key_octave 

type Key_octave struct {
	Name  string
	Value *Octave `xml:",chardata" json:"-,"`

	Number *PositiveInteger `xml:"number,attr,omitempty" json:"number,omitempty"`

	Cancel *Yes_no `xml:"cancel,attr,omitempty" json:"cancel,omitempty"`
}

func CopyBranchKey_octave 

func CopyBranchKey_octave(mapOrigCopy map[any]any, key_octaveFrom *Key_octave) (key_octaveTo *Key_octave)

func (*Key_octave) Checkout 

func (key_octave *Key_octave) Checkout(stage *StageStruct) *Key_octave

Checkout key_octave to the back repo (if it is already staged)

func (*Key_octave) Commit 

func (key_octave *Key_octave) Commit(stage *StageStruct) *Key_octave

commit key_octave to the back repo (if it is already staged)

func (*Key_octave) CommitVoid 

func (key_octave *Key_octave) CommitVoid(stage *StageStruct)

func (*Key_octave) CopyBasicFields 

func (from *Key_octave) CopyBasicFields(to *Key_octave)

func (*Key_octave) GetName 

func (key_octave *Key_octave) GetName() (res string)

for satisfaction of GongStruct interface

func (*Key_octave) Stage 

func (key_octave *Key_octave) Stage(stage *StageStruct) *Key_octave

Stage puts key_octave to the model stage

func (*Key_octave) Unstage 

func (key_octave *Key_octave) Unstage(stage *StageStruct) *Key_octave

Unstage removes key_octave off the model stage

func (*Key_octave) UnstageVoid 

func (key_octave *Key_octave) UnstageVoid(stage *StageStruct)

UnstageVoid removes key_octave off the model stage

type Key_octave_WOP 

type Key_octave_WOP struct {
	// insertion point
	Name string
}

type Kind 

type Kind struct {
	Name  string
	Value *Kind_value `xml:",chardata" json:"-,"`

	Use_symbols *Yes_no `xml:"use-symbols,attr,omitempty" json:"use-symbols,omitempty"`

	Text string `xml:"text,attr,omitempty" json:"text,omitempty"`

	Stack_degrees *Yes_no `xml:"stack-degrees,attr,omitempty" json:"stack-degrees,omitempty"`

	Parentheses_degrees *Yes_no `xml:"parentheses-degrees,attr,omitempty" json:"parentheses-degrees,omitempty"`

	Bracket_degrees *Yes_no `xml:"bracket-degrees,attr,omitempty" json:"bracket-degrees,omitempty"`
}

func CopyBranchKind 

func CopyBranchKind(mapOrigCopy map[any]any, kindFrom *Kind) (kindTo *Kind)

func (*Kind) Checkout 

func (kind *Kind) Checkout(stage *StageStruct) *Kind

Checkout kind to the back repo (if it is already staged)

func (*Kind) Commit 

func (kind *Kind) Commit(stage *StageStruct) *Kind

commit kind to the back repo (if it is already staged)

func (*Kind) CommitVoid 

func (kind *Kind) CommitVoid(stage *StageStruct)

func (*Kind) CopyBasicFields 

func (from *Kind) CopyBasicFields(to *Kind)

func (*Kind) GetName 

func (kind *Kind) GetName() (res string)

for satisfaction of GongStruct interface

func (*Kind) Stage 

func (kind *Kind) Stage(stage *StageStruct) *Kind

Stage puts kind to the model stage

func (*Kind) Unstage 

func (kind *Kind) Unstage(stage *StageStruct) *Kind

Unstage removes kind off the model stage

func (*Kind) UnstageVoid 

func (kind *Kind) UnstageVoid(stage *StageStruct)

UnstageVoid removes kind off the model stage

type Kind_WOP 

type Kind_WOP struct {
	// insertion point
	Name string
	Text string
}

type Kind_value 

type Kind_value string
const (
	Kind_valueMajor Kind_value = "major"

	Kind_valueMinor Kind_value = "minor"

	Kind_valueAugmented Kind_value = "augmented"

	Kind_valueDiminished Kind_value = "diminished"

	Kind_valueDominant Kind_value = "dominant"

	Kind_valueMajor_seventh Kind_value = "major-seventh"

	Kind_valueMinor_seventh Kind_value = "minor-seventh"

	Kind_valueDiminished_seventh Kind_value = "diminished-seventh"

	Kind_valueAugmented_seventh Kind_value = "augmented-seventh"

	Kind_valueHalf_diminished Kind_value = "half-diminished"

	Kind_valueMajor_minor Kind_value = "major-minor"

	Kind_valueMajor_sixth Kind_value = "major-sixth"

	Kind_valueMinor_sixth Kind_value = "minor-sixth"

	Kind_valueDominant_ninth Kind_value = "dominant-ninth"

	Kind_valueMajor_ninth Kind_value = "major-ninth"

	Kind_valueMinor_ninth Kind_value = "minor-ninth"

	Kind_valueDominant_11th Kind_value = "dominant-11th"

	Kind_valueMajor_11th Kind_value = "major-11th"

	Kind_valueMinor_11th Kind_value = "minor-11th"

	Kind_valueDominant_13th Kind_value = "dominant-13th"

	Kind_valueMajor_13th Kind_value = "major-13th"

	Kind_valueMinor_13th Kind_value = "minor-13th"

	Kind_valueSuspended_second Kind_value = "suspended-second"

	Kind_valueSuspended_fourth Kind_value = "suspended-fourth"

	Kind_valueNeapolitan Kind_value = "Neapolitan"

	Kind_valueItalian Kind_value = "Italian"

	Kind_valueFrench Kind_value = "French"

	Kind_valueGerman Kind_value = "German"

	Kind_valuePedal Kind_value = "pedal"

	Kind_valuePower Kind_value = "power"

	Kind_valueTristan Kind_value = "Tristan"

	Kind_valueOther Kind_value = "other"

	Kind_valueNone Kind_value = "none"
)

func (Kind_value) CodeValues 

func (kind_value Kind_value) CodeValues() (res []string)

func (Kind_value) Codes 

func (kind_value Kind_value) Codes() (res []string)

func (*Kind_value) FromCodeString 

func (kind_value *Kind_value) FromCodeString(input string) (err error)

func (*Kind_value) FromString 

func (kind_value *Kind_value) FromString(input string) (err error)

func (*Kind_value) ToCodeString 

func (kind_value *Kind_value) ToCodeString() (res string)

func (Kind_value) ToString 

func (kind_value Kind_value) ToString() (res string)

Utility function for Kind_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Left_center_right 

type Left_center_right string
const (
	Left_center_rightLeft Left_center_right = "left"

	Left_center_rightCenter Left_center_right = "center"

	Left_center_rightRight Left_center_right = "right"
)

func (Left_center_right) CodeValues 

func (left_center_right Left_center_right) CodeValues() (res []string)

func (Left_center_right) Codes 

func (left_center_right Left_center_right) Codes() (res []string)

func (*Left_center_right) FromCodeString 

func (left_center_right *Left_center_right) FromCodeString(input string) (err error)

func (*Left_center_right) FromString 

func (left_center_right *Left_center_right) FromString(input string) (err error)

func (*Left_center_right) ToCodeString 

func (left_center_right *Left_center_right) ToCodeString() (res string)

func (Left_center_right) ToString 

func (left_center_right Left_center_right) ToString() (res string)

Utility function for Left_center_right if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Left_right 

type Left_right string
const (
	Left_rightLeft Left_right = "left"

	Left_rightRight Left_right = "right"
)

func (Left_right) CodeValues 

func (left_right Left_right) CodeValues() (res []string)

func (Left_right) Codes 

func (left_right Left_right) Codes() (res []string)

func (*Left_right) FromCodeString 

func (left_right *Left_right) FromCodeString(input string) (err error)

func (*Left_right) FromString 

func (left_right *Left_right) FromString(input string) (err error)

func (*Left_right) ToCodeString 

func (left_right *Left_right) ToCodeString() (res string)

func (Left_right) ToString 

func (left_right Left_right) ToString() (res string)

Utility function for Left_right if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Level 

type Level struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Reference *Yes_no `xml:"reference,attr,omitempty" json:"reference,omitempty"`

	Type *Start_stop_single `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchLevel 

func CopyBranchLevel(mapOrigCopy map[any]any, levelFrom *Level) (levelTo *Level)

func (*Level) Checkout 

func (level *Level) Checkout(stage *StageStruct) *Level

Checkout level to the back repo (if it is already staged)

func (*Level) Commit 

func (level *Level) Commit(stage *StageStruct) *Level

commit level to the back repo (if it is already staged)

func (*Level) CommitVoid 

func (level *Level) CommitVoid(stage *StageStruct)

func (*Level) CopyBasicFields 

func (from *Level) CopyBasicFields(to *Level)

func (*Level) GetName 

func (level *Level) GetName() (res string)

for satisfaction of GongStruct interface

func (*Level) Stage 

func (level *Level) Stage(stage *StageStruct) *Level

Stage puts level to the model stage

func (*Level) Unstage 

func (level *Level) Unstage(stage *StageStruct) *Level

Unstage removes level off the model stage

func (*Level) UnstageVoid 

func (level *Level) UnstageVoid(stage *StageStruct)

UnstageVoid removes level off the model stage

type Level_WOP 

type Level_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Line_detail 

type Line_detail struct {
	Name string
	Line *Staff_line `xml:"line,attr,omitempty" json:"line,omitempty"`

	Width *Tenths `xml:"width,attr,omitempty" json:"width,omitempty"`
}

func CopyBranchLine_detail 

func CopyBranchLine_detail(mapOrigCopy map[any]any, line_detailFrom *Line_detail) (line_detailTo *Line_detail)

func (*Line_detail) Checkout 

func (line_detail *Line_detail) Checkout(stage *StageStruct) *Line_detail

Checkout line_detail to the back repo (if it is already staged)

func (*Line_detail) Commit 

func (line_detail *Line_detail) Commit(stage *StageStruct) *Line_detail

commit line_detail to the back repo (if it is already staged)

func (*Line_detail) CommitVoid 

func (line_detail *Line_detail) CommitVoid(stage *StageStruct)

func (*Line_detail) CopyBasicFields 

func (from *Line_detail) CopyBasicFields(to *Line_detail)

func (*Line_detail) GetName 

func (line_detail *Line_detail) GetName() (res string)

for satisfaction of GongStruct interface

func (*Line_detail) Stage 

func (line_detail *Line_detail) Stage(stage *StageStruct) *Line_detail

Stage puts line_detail to the model stage

func (*Line_detail) Unstage 

func (line_detail *Line_detail) Unstage(stage *StageStruct) *Line_detail

Unstage removes line_detail off the model stage

func (*Line_detail) UnstageVoid 

func (line_detail *Line_detail) UnstageVoid(stage *StageStruct)

UnstageVoid removes line_detail off the model stage

type Line_detail_WOP 

type Line_detail_WOP struct {
	// insertion point
	Name string
}

type Line_end 

type Line_end string
const (
	Line_endUp Line_end = "up"

	Line_endDown Line_end = "down"

	Line_endBoth Line_end = "both"

	Line_endArrow Line_end = "arrow"

	Line_endNone Line_end = "none"
)

func (Line_end) CodeValues 

func (line_end Line_end) CodeValues() (res []string)

func (Line_end) Codes 

func (line_end Line_end) Codes() (res []string)

func (*Line_end) FromCodeString 

func (line_end *Line_end) FromCodeString(input string) (err error)

func (*Line_end) FromString 

func (line_end *Line_end) FromString(input string) (err error)

func (*Line_end) ToCodeString 

func (line_end *Line_end) ToCodeString() (res string)

func (Line_end) ToString 

func (line_end Line_end) ToString() (res string)

Utility function for Line_end if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Line_length 

type Line_length string
const (
	Line_lengthShort Line_length = "short"

	Line_lengthMedium Line_length = "medium"

	Line_lengthLong Line_length = "long"
)

func (Line_length) CodeValues 

func (line_length Line_length) CodeValues() (res []string)

func (Line_length) Codes 

func (line_length Line_length) Codes() (res []string)

func (*Line_length) FromCodeString 

func (line_length *Line_length) FromCodeString(input string) (err error)

func (*Line_length) FromString 

func (line_length *Line_length) FromString(input string) (err error)

func (*Line_length) ToCodeString 

func (line_length *Line_length) ToCodeString() (res string)

func (Line_length) ToString 

func (line_length Line_length) ToString() (res string)

Utility function for Line_length if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Line_shape 

type Line_shape string
const (
	Line_shapeStraight Line_shape = "straight"

	Line_shapeCurved Line_shape = "curved"
)

func (Line_shape) CodeValues 

func (line_shape Line_shape) CodeValues() (res []string)

func (Line_shape) Codes 

func (line_shape Line_shape) Codes() (res []string)

func (*Line_shape) FromCodeString 

func (line_shape *Line_shape) FromCodeString(input string) (err error)

func (*Line_shape) FromString 

func (line_shape *Line_shape) FromString(input string) (err error)

func (*Line_shape) ToCodeString 

func (line_shape *Line_shape) ToCodeString() (res string)

func (Line_shape) ToString 

func (line_shape Line_shape) ToString() (res string)

Utility function for Line_shape if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Line_type 

type Line_type string
const (
	Line_typeSolid Line_type = "solid"

	Line_typeDashed Line_type = "dashed"

	Line_typeDotted Line_type = "dotted"

	Line_typeWavy Line_type = "wavy"
)

func (Line_type) CodeValues 

func (line_type Line_type) CodeValues() (res []string)

func (Line_type) Codes 

func (line_type Line_type) Codes() (res []string)

func (*Line_type) FromCodeString 

func (line_type *Line_type) FromCodeString(input string) (err error)

func (*Line_type) FromString 

func (line_type *Line_type) FromString(input string) (err error)

func (*Line_type) ToCodeString 

func (line_type *Line_type) ToCodeString() (res string)

func (Line_type) ToString 

func (line_type Line_type) ToString() (res string)

Utility function for Line_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Line_width 

type Line_width struct {
	Name  string
	Value *Tenths `xml:",chardata" json:"-,"`

	Type *Line_width_type `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchLine_width 

func CopyBranchLine_width(mapOrigCopy map[any]any, line_widthFrom *Line_width) (line_widthTo *Line_width)

func (*Line_width) Checkout 

func (line_width *Line_width) Checkout(stage *StageStruct) *Line_width

Checkout line_width to the back repo (if it is already staged)

func (*Line_width) Commit 

func (line_width *Line_width) Commit(stage *StageStruct) *Line_width

commit line_width to the back repo (if it is already staged)

func (*Line_width) CommitVoid 

func (line_width *Line_width) CommitVoid(stage *StageStruct)

func (*Line_width) CopyBasicFields 

func (from *Line_width) CopyBasicFields(to *Line_width)

func (*Line_width) GetName 

func (line_width *Line_width) GetName() (res string)

for satisfaction of GongStruct interface

func (*Line_width) Stage 

func (line_width *Line_width) Stage(stage *StageStruct) *Line_width

Stage puts line_width to the model stage

func (*Line_width) Unstage 

func (line_width *Line_width) Unstage(stage *StageStruct) *Line_width

Unstage removes line_width off the model stage

func (*Line_width) UnstageVoid 

func (line_width *Line_width) UnstageVoid(stage *StageStruct)

UnstageVoid removes line_width off the model stage

type Line_width_WOP 

type Line_width_WOP struct {
	// insertion point
	Name string
}

type Line_width_type 

type Line_width_type string

func (Line_width_type) CodeValues 

func (line_width_type Line_width_type) CodeValues() (res []string)

func (Line_width_type) Codes 

func (line_width_type Line_width_type) Codes() (res []string)

func (*Line_width_type) FromCodeString 

func (line_width_type *Line_width_type) FromCodeString(input string) (err error)

func (*Line_width_type) FromString 

func (line_width_type *Line_width_type) FromString(input string) (err error)

func (*Line_width_type) ToCodeString 

func (line_width_type *Line_width_type) ToCodeString() (res string)

func (Line_width_type) ToString 

func (line_width_type Line_width_type) ToString() (res string)

Utility function for Line_width_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value 

type Link struct {
	Name string `xml:"name,attr,omitempty" json:"name,omitempty"`
}
func CopyBranchLink(mapOrigCopy map[any]any, linkFrom *Link) (linkTo *Link)

func (*Link) Checkout 

func (link *Link) Checkout(stage *StageStruct) *Link

Checkout link to the back repo (if it is already staged)

func (*Link) Commit 

func (link *Link) Commit(stage *StageStruct) *Link

commit link to the back repo (if it is already staged)

func (*Link) CommitVoid 

func (link *Link) CommitVoid(stage *StageStruct)

func (*Link) CopyBasicFields 

func (from *Link) CopyBasicFields(to *Link)

func (*Link) GetName 

func (link *Link) GetName() (res string)

for satisfaction of GongStruct interface

func (*Link) Stage 

func (link *Link) Stage(stage *StageStruct) *Link

Stage puts link to the model stage

func (*Link) Unstage 

func (link *Link) Unstage(stage *StageStruct) *Link

Unstage removes link off the model stage

func (*Link) UnstageVoid 

func (link *Link) UnstageVoid(stage *StageStruct)

UnstageVoid removes link off the model stage 

type Link_WOP struct {
	// insertion point
	Name string
}

type Listen 

type Listen struct {
	Name   string
	Assess *Assess `xml:"assess,omitempty" json:"assess,omitempty"`

	Wait *Wait `xml:"wait,omitempty" json:"wait,omitempty"`

	Other_listen *Other_listening `xml:"other-listen,omitempty" json:"other-listen,omitempty"`
}

func CopyBranchListen 

func CopyBranchListen(mapOrigCopy map[any]any, listenFrom *Listen) (listenTo *Listen)

func (*Listen) Checkout 

func (listen *Listen) Checkout(stage *StageStruct) *Listen

Checkout listen to the back repo (if it is already staged)

func (*Listen) Commit 

func (listen *Listen) Commit(stage *StageStruct) *Listen

commit listen to the back repo (if it is already staged)

func (*Listen) CommitVoid 

func (listen *Listen) CommitVoid(stage *StageStruct)

func (*Listen) CopyBasicFields 

func (from *Listen) CopyBasicFields(to *Listen)

func (*Listen) GetName 

func (listen *Listen) GetName() (res string)

for satisfaction of GongStruct interface

func (*Listen) Stage 

func (listen *Listen) Stage(stage *StageStruct) *Listen

Stage puts listen to the model stage

func (*Listen) Unstage 

func (listen *Listen) Unstage(stage *StageStruct) *Listen

Unstage removes listen off the model stage

func (*Listen) UnstageVoid 

func (listen *Listen) UnstageVoid(stage *StageStruct)

UnstageVoid removes listen off the model stage

type Listen_WOP 

type Listen_WOP struct {
	// insertion point
	Name string
}

type Listening 

type Listening struct {
	Name   string
	Offset *Offset `xml:"offset,omitempty" json:"offset,omitempty"`

	Sync *Sync `xml:"sync,omitempty" json:"sync,omitempty"`

	Other_listening *Other_listening `xml:"other-listening,omitempty" json:"other-listening,omitempty"`
}

func CopyBranchListening 

func CopyBranchListening(mapOrigCopy map[any]any, listeningFrom *Listening) (listeningTo *Listening)

func (*Listening) Checkout 

func (listening *Listening) Checkout(stage *StageStruct) *Listening

Checkout listening to the back repo (if it is already staged)

func (*Listening) Commit 

func (listening *Listening) Commit(stage *StageStruct) *Listening

commit listening to the back repo (if it is already staged)

func (*Listening) CommitVoid 

func (listening *Listening) CommitVoid(stage *StageStruct)

func (*Listening) CopyBasicFields 

func (from *Listening) CopyBasicFields(to *Listening)

func (*Listening) GetName 

func (listening *Listening) GetName() (res string)

for satisfaction of GongStruct interface

func (*Listening) Stage 

func (listening *Listening) Stage(stage *StageStruct) *Listening

Stage puts listening to the model stage

func (*Listening) Unstage 

func (listening *Listening) Unstage(stage *StageStruct) *Listening

Unstage removes listening off the model stage

func (*Listening) UnstageVoid 

func (listening *Listening) UnstageVoid(stage *StageStruct)

UnstageVoid removes listening off the model stage

type Listening_WOP 

type Listening_WOP struct {
	// insertion point
	Name string
}

type Lyric 

type Lyric struct {

	// The end-line element comes from RP-017 for Standard MIDI File
	// Lyric meta-events. It facilitates lyric display for Karaoke and similar
	// applications.
	End_line *Empty `xml:"end-line,omitempty" json:"end-line,omitempty"`

	// The end-paragraph element comes from RP-017 for Standard MIDI
	// File Lyric meta-events. It facilitates lyric display for Karaoke and similar
	// applications.
	End_paragraph *Empty `xml:"end-paragraph,omitempty" json:"end-paragraph,omitempty"`

	Extend *Extend `xml:"extend,omitempty" json:"extend,omitempty"`

	// The laughing element represents a laughing voice.
	Laughing *Empty `xml:"laughing,omitempty" json:"laughing,omitempty"`

	// The humming element represents a humming voice.
	Humming *Empty `xml:"humming,omitempty" json:"humming,omitempty"`

	Number *NMTOKEN `xml:"number,attr,omitempty" json:"number,omitempty"`

	Name string `xml:"name,attr,omitempty" json:"name,omitempty"`

	Time_only *Time_only `xml:"time-only,attr,omitempty" json:"time-only,omitempty"`
}

func CopyBranchLyric 

func CopyBranchLyric(mapOrigCopy map[any]any, lyricFrom *Lyric) (lyricTo *Lyric)

func (*Lyric) Checkout 

func (lyric *Lyric) Checkout(stage *StageStruct) *Lyric

Checkout lyric to the back repo (if it is already staged)

func (*Lyric) Commit 

func (lyric *Lyric) Commit(stage *StageStruct) *Lyric

commit lyric to the back repo (if it is already staged)

func (*Lyric) CommitVoid 

func (lyric *Lyric) CommitVoid(stage *StageStruct)

func (*Lyric) CopyBasicFields 

func (from *Lyric) CopyBasicFields(to *Lyric)

func (*Lyric) GetName 

func (lyric *Lyric) GetName() (res string)

for satisfaction of GongStruct interface

func (*Lyric) Stage 

func (lyric *Lyric) Stage(stage *StageStruct) *Lyric

Stage puts lyric to the model stage

func (*Lyric) Unstage 

func (lyric *Lyric) Unstage(stage *StageStruct) *Lyric

Unstage removes lyric off the model stage

func (*Lyric) UnstageVoid 

func (lyric *Lyric) UnstageVoid(stage *StageStruct)

UnstageVoid removes lyric off the model stage

type Lyric_WOP 

type Lyric_WOP struct {
	// insertion point
	Name string
}

type Lyric_font 

type Lyric_font struct {
	Number *NMTOKEN `xml:"number,attr,omitempty" json:"number,omitempty"`

	Name string `xml:"name,attr,omitempty" json:"name,omitempty"`
}

func CopyBranchLyric_font 

func CopyBranchLyric_font(mapOrigCopy map[any]any, lyric_fontFrom *Lyric_font) (lyric_fontTo *Lyric_font)

func (*Lyric_font) Checkout 

func (lyric_font *Lyric_font) Checkout(stage *StageStruct) *Lyric_font

Checkout lyric_font to the back repo (if it is already staged)

func (*Lyric_font) Commit 

func (lyric_font *Lyric_font) Commit(stage *StageStruct) *Lyric_font

commit lyric_font to the back repo (if it is already staged)

func (*Lyric_font) CommitVoid 

func (lyric_font *Lyric_font) CommitVoid(stage *StageStruct)

func (*Lyric_font) CopyBasicFields 

func (from *Lyric_font) CopyBasicFields(to *Lyric_font)

func (*Lyric_font) GetName 

func (lyric_font *Lyric_font) GetName() (res string)

for satisfaction of GongStruct interface

func (*Lyric_font) Stage 

func (lyric_font *Lyric_font) Stage(stage *StageStruct) *Lyric_font

Stage puts lyric_font to the model stage

func (*Lyric_font) Unstage 

func (lyric_font *Lyric_font) Unstage(stage *StageStruct) *Lyric_font

Unstage removes lyric_font off the model stage

func (*Lyric_font) UnstageVoid 

func (lyric_font *Lyric_font) UnstageVoid(stage *StageStruct)

UnstageVoid removes lyric_font off the model stage

type Lyric_font_WOP 

type Lyric_font_WOP struct {
	// insertion point
	Name string
}

type Lyric_language 

type Lyric_language struct {
	Number *NMTOKEN `xml:"number,attr,omitempty" json:"number,omitempty"`

	Name string `xml:"name,attr,omitempty" json:"name,omitempty"`

	EmptyString string `xml:",attr,omitempty" json:",omitempty"`
}

func CopyBranchLyric_language 

func CopyBranchLyric_language(mapOrigCopy map[any]any, lyric_languageFrom *Lyric_language) (lyric_languageTo *Lyric_language)

func (*Lyric_language) Checkout 

func (lyric_language *Lyric_language) Checkout(stage *StageStruct) *Lyric_language

Checkout lyric_language to the back repo (if it is already staged)

func (*Lyric_language) Commit 

func (lyric_language *Lyric_language) Commit(stage *StageStruct) *Lyric_language

commit lyric_language to the back repo (if it is already staged)

func (*Lyric_language) CommitVoid 

func (lyric_language *Lyric_language) CommitVoid(stage *StageStruct)

func (*Lyric_language) CopyBasicFields 

func (from *Lyric_language) CopyBasicFields(to *Lyric_language)

func (*Lyric_language) GetName 

func (lyric_language *Lyric_language) GetName() (res string)

for satisfaction of GongStruct interface

func (*Lyric_language) Stage 

func (lyric_language *Lyric_language) Stage(stage *StageStruct) *Lyric_language

Stage puts lyric_language to the model stage

func (*Lyric_language) Unstage 

func (lyric_language *Lyric_language) Unstage(stage *StageStruct) *Lyric_language

Unstage removes lyric_language off the model stage

func (*Lyric_language) UnstageVoid 

func (lyric_language *Lyric_language) UnstageVoid(stage *StageStruct)

UnstageVoid removes lyric_language off the model stage

type Lyric_language_WOP 

type Lyric_language_WOP struct {
	// insertion point
	Name        string
	EmptyString string
}

type Margin_type 

type Margin_type string
const (
	Margin_typeOdd Margin_type = "odd"

	Margin_typeEven Margin_type = "even"

	Margin_typeBoth Margin_type = "both"
)

func (Margin_type) CodeValues 

func (margin_type Margin_type) CodeValues() (res []string)

func (Margin_type) Codes 

func (margin_type Margin_type) Codes() (res []string)

func (*Margin_type) FromCodeString 

func (margin_type *Margin_type) FromCodeString(input string) (err error)

func (*Margin_type) FromString 

func (margin_type *Margin_type) FromString(input string) (err error)

func (*Margin_type) ToCodeString 

func (margin_type *Margin_type) ToCodeString() (res string)

func (Margin_type) ToString 

func (margin_type Margin_type) ToString() (res string)

Utility function for Margin_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Measure_layout 

type Measure_layout struct {
	Name string

	// The measure-distance element specifies the horizontal distance
	// from the previous measure. This value is only used for systems where there
	// is horizontal whitespace in the middle of a system, as in systems with
	// codas. To specify the measure width, use the width attribute of the measure
	// element.
	Measure_distance *Tenths `xml:"measure-distance,omitempty" json:"measure-distance,omitempty"`
}

func CopyBranchMeasure_layout 

func CopyBranchMeasure_layout(mapOrigCopy map[any]any, measure_layoutFrom *Measure_layout) (measure_layoutTo *Measure_layout)

func (*Measure_layout) Checkout 

func (measure_layout *Measure_layout) Checkout(stage *StageStruct) *Measure_layout

Checkout measure_layout to the back repo (if it is already staged)

func (*Measure_layout) Commit 

func (measure_layout *Measure_layout) Commit(stage *StageStruct) *Measure_layout

commit measure_layout to the back repo (if it is already staged)

func (*Measure_layout) CommitVoid 

func (measure_layout *Measure_layout) CommitVoid(stage *StageStruct)

func (*Measure_layout) CopyBasicFields 

func (from *Measure_layout) CopyBasicFields(to *Measure_layout)

func (*Measure_layout) GetName 

func (measure_layout *Measure_layout) GetName() (res string)

for satisfaction of GongStruct interface

func (*Measure_layout) Stage 

func (measure_layout *Measure_layout) Stage(stage *StageStruct) *Measure_layout

Stage puts measure_layout to the model stage

func (*Measure_layout) Unstage 

func (measure_layout *Measure_layout) Unstage(stage *StageStruct) *Measure_layout

Unstage removes measure_layout off the model stage

func (*Measure_layout) UnstageVoid 

func (measure_layout *Measure_layout) UnstageVoid(stage *StageStruct)

UnstageVoid removes measure_layout off the model stage

type Measure_layout_WOP 

type Measure_layout_WOP struct {
	// insertion point
	Name string
}

type Measure_numbering 

type Measure_numbering struct {
	Name  string
	Value *Measure_numbering_value `xml:",chardata" json:"-,"`

	System *System_relation_number `xml:"system,attr,omitempty" json:"system,omitempty"`

	Staff *Staff_number `xml:"staff,attr,omitempty" json:"staff,omitempty"`

	Multiple_rest_always *Yes_no `xml:"multiple-rest-always,attr,omitempty" json:"multiple-rest-always,omitempty"`

	Multiple_rest_range *Yes_no `xml:"multiple-rest-range,attr,omitempty" json:"multiple-rest-range,omitempty"`
}

func CopyBranchMeasure_numbering 

func CopyBranchMeasure_numbering(mapOrigCopy map[any]any, measure_numberingFrom *Measure_numbering) (measure_numberingTo *Measure_numbering)

func (*Measure_numbering) Checkout 

func (measure_numbering *Measure_numbering) Checkout(stage *StageStruct) *Measure_numbering

Checkout measure_numbering to the back repo (if it is already staged)

func (*Measure_numbering) Commit 

func (measure_numbering *Measure_numbering) Commit(stage *StageStruct) *Measure_numbering

commit measure_numbering to the back repo (if it is already staged)

func (*Measure_numbering) CommitVoid 

func (measure_numbering *Measure_numbering) CommitVoid(stage *StageStruct)

func (*Measure_numbering) CopyBasicFields 

func (from *Measure_numbering) CopyBasicFields(to *Measure_numbering)

func (*Measure_numbering) GetName 

func (measure_numbering *Measure_numbering) GetName() (res string)

for satisfaction of GongStruct interface

func (*Measure_numbering) Stage 

func (measure_numbering *Measure_numbering) Stage(stage *StageStruct) *Measure_numbering

Stage puts measure_numbering to the model stage

func (*Measure_numbering) Unstage 

func (measure_numbering *Measure_numbering) Unstage(stage *StageStruct) *Measure_numbering

Unstage removes measure_numbering off the model stage

func (*Measure_numbering) UnstageVoid 

func (measure_numbering *Measure_numbering) UnstageVoid(stage *StageStruct)

UnstageVoid removes measure_numbering off the model stage

type Measure_numbering_WOP 

type Measure_numbering_WOP struct {
	// insertion point
	Name string
}

type Measure_numbering_value 

type Measure_numbering_value string
const (
	Measure_numbering_valueNone Measure_numbering_value = "none"

	Measure_numbering_valueMeasure Measure_numbering_value = "measure"

	Measure_numbering_valueSystem Measure_numbering_value = "system"
)

func (Measure_numbering_value) CodeValues 

func (measure_numbering_value Measure_numbering_value) CodeValues() (res []string)

func (Measure_numbering_value) Codes 

func (measure_numbering_value Measure_numbering_value) Codes() (res []string)

func (*Measure_numbering_value) FromCodeString 

func (measure_numbering_value *Measure_numbering_value) FromCodeString(input string) (err error)

func (*Measure_numbering_value) FromString 

func (measure_numbering_value *Measure_numbering_value) FromString(input string) (err error)

func (*Measure_numbering_value) ToCodeString 

func (measure_numbering_value *Measure_numbering_value) ToCodeString() (res string)

func (Measure_numbering_value) ToString 

func (measure_numbering_value Measure_numbering_value) ToString() (res string)

Utility function for Measure_numbering_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Measure_repeat 

type Measure_repeat struct {
	Name  string
	Value *Positive_integer_or_empty `xml:",chardata" json:"-,"`

	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Slashes *PositiveInteger `xml:"slashes,attr,omitempty" json:"slashes,omitempty"`
}

func CopyBranchMeasure_repeat 

func CopyBranchMeasure_repeat(mapOrigCopy map[any]any, measure_repeatFrom *Measure_repeat) (measure_repeatTo *Measure_repeat)

func (*Measure_repeat) Checkout 

func (measure_repeat *Measure_repeat) Checkout(stage *StageStruct) *Measure_repeat

Checkout measure_repeat to the back repo (if it is already staged)

func (*Measure_repeat) Commit 

func (measure_repeat *Measure_repeat) Commit(stage *StageStruct) *Measure_repeat

commit measure_repeat to the back repo (if it is already staged)

func (*Measure_repeat) CommitVoid 

func (measure_repeat *Measure_repeat) CommitVoid(stage *StageStruct)

func (*Measure_repeat) CopyBasicFields 

func (from *Measure_repeat) CopyBasicFields(to *Measure_repeat)

func (*Measure_repeat) GetName 

func (measure_repeat *Measure_repeat) GetName() (res string)

for satisfaction of GongStruct interface

func (*Measure_repeat) Stage 

func (measure_repeat *Measure_repeat) Stage(stage *StageStruct) *Measure_repeat

Stage puts measure_repeat to the model stage

func (*Measure_repeat) Unstage 

func (measure_repeat *Measure_repeat) Unstage(stage *StageStruct) *Measure_repeat

Unstage removes measure_repeat off the model stage

func (*Measure_repeat) UnstageVoid 

func (measure_repeat *Measure_repeat) UnstageVoid(stage *StageStruct)

UnstageVoid removes measure_repeat off the model stage

type Measure_repeat_WOP 

type Measure_repeat_WOP struct {
	// insertion point
	Name string
}

type Measure_style 

type Measure_style struct {
	Name          string
	Multiple_rest *Multiple_rest `xml:"multiple-rest,omitempty" json:"multiple-rest,omitempty"`

	Measure_repeat *Measure_repeat `xml:"measure-repeat,omitempty" json:"measure-repeat,omitempty"`

	Beat_repeat *Beat_repeat `xml:"beat-repeat,omitempty" json:"beat-repeat,omitempty"`

	Slash *Slash `xml:"slash,omitempty" json:"slash,omitempty"`

	Number *Staff_number `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchMeasure_style 

func CopyBranchMeasure_style(mapOrigCopy map[any]any, measure_styleFrom *Measure_style) (measure_styleTo *Measure_style)

func (*Measure_style) Checkout 

func (measure_style *Measure_style) Checkout(stage *StageStruct) *Measure_style

Checkout measure_style to the back repo (if it is already staged)

func (*Measure_style) Commit 

func (measure_style *Measure_style) Commit(stage *StageStruct) *Measure_style

commit measure_style to the back repo (if it is already staged)

func (*Measure_style) CommitVoid 

func (measure_style *Measure_style) CommitVoid(stage *StageStruct)

func (*Measure_style) CopyBasicFields 

func (from *Measure_style) CopyBasicFields(to *Measure_style)

func (*Measure_style) GetName 

func (measure_style *Measure_style) GetName() (res string)

for satisfaction of GongStruct interface

func (*Measure_style) Stage 

func (measure_style *Measure_style) Stage(stage *StageStruct) *Measure_style

Stage puts measure_style to the model stage

func (*Measure_style) Unstage 

func (measure_style *Measure_style) Unstage(stage *StageStruct) *Measure_style

Unstage removes measure_style off the model stage

func (*Measure_style) UnstageVoid 

func (measure_style *Measure_style) UnstageVoid(stage *StageStruct)

UnstageVoid removes measure_style off the model stage

type Measure_style_WOP 

type Measure_style_WOP struct {
	// insertion point
	Name string
}

type Measure_text 

type Measure_text string

func (Measure_text) CodeValues 

func (measure_text Measure_text) CodeValues() (res []string)

func (Measure_text) Codes 

func (measure_text Measure_text) Codes() (res []string)

func (*Measure_text) FromCodeString 

func (measure_text *Measure_text) FromCodeString(input string) (err error)

func (*Measure_text) FromString 

func (measure_text *Measure_text) FromString(input string) (err error)

func (*Measure_text) ToCodeString 

func (measure_text *Measure_text) ToCodeString() (res string)

func (Measure_text) ToString 

func (measure_text Measure_text) ToString() (res string)

Utility function for Measure_text if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Membrane 

type Membrane struct {
	Name  string
	Value *Membrane_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_pictogram_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchMembrane 

func CopyBranchMembrane(mapOrigCopy map[any]any, membraneFrom *Membrane) (membraneTo *Membrane)

func (*Membrane) Checkout 

func (membrane *Membrane) Checkout(stage *StageStruct) *Membrane

Checkout membrane to the back repo (if it is already staged)

func (*Membrane) Commit 

func (membrane *Membrane) Commit(stage *StageStruct) *Membrane

commit membrane to the back repo (if it is already staged)

func (*Membrane) CommitVoid 

func (membrane *Membrane) CommitVoid(stage *StageStruct)

func (*Membrane) CopyBasicFields 

func (from *Membrane) CopyBasicFields(to *Membrane)

func (*Membrane) GetName 

func (membrane *Membrane) GetName() (res string)

for satisfaction of GongStruct interface

func (*Membrane) Stage 

func (membrane *Membrane) Stage(stage *StageStruct) *Membrane

Stage puts membrane to the model stage

func (*Membrane) Unstage 

func (membrane *Membrane) Unstage(stage *StageStruct) *Membrane

Unstage removes membrane off the model stage

func (*Membrane) UnstageVoid 

func (membrane *Membrane) UnstageVoid(stage *StageStruct)

UnstageVoid removes membrane off the model stage

type Membrane_WOP 

type Membrane_WOP struct {
	// insertion point
	Name string
}

type Membrane_value 

type Membrane_value string
const (
	Membrane_valueBassdrum Membrane_value = "bass drum"

	Membrane_valueBassdrumonside Membrane_value = "bass drum on side"

	Membrane_valueBongos Membrane_value = "bongos"

	Membrane_valueChinesetomtom Membrane_value = "Chinese tomtom"

	Membrane_valueCongadrum Membrane_value = "conga drum"

	Membrane_valueCuica Membrane_value = "cuica"

	Membrane_valueGobletdrum Membrane_value = "goblet drum"

	Membrane_valueIndo_Americantomtom Membrane_value = "Indo-American tomtom"

	Membrane_valueJapanesetomtom Membrane_value = "Japanese tomtom"

	Membrane_valueMilitarydrum Membrane_value = "military drum"

	Membrane_valueSnaredrum Membrane_value = "snare drum"

	Membrane_valueSnaredrumsnaresoff Membrane_value = "snare drum snares off"

	Membrane_valueTabla Membrane_value = "tabla"

	Membrane_valueTambourine Membrane_value = "tambourine"

	Membrane_valueTenordrum Membrane_value = "tenor drum"

	Membrane_valueTimbales Membrane_value = "timbales"

	Membrane_valueTomtom Membrane_value = "tomtom"
)

func (Membrane_value) CodeValues 

func (membrane_value Membrane_value) CodeValues() (res []string)

func (Membrane_value) Codes 

func (membrane_value Membrane_value) Codes() (res []string)

func (*Membrane_value) FromCodeString 

func (membrane_value *Membrane_value) FromCodeString(input string) (err error)

func (*Membrane_value) FromString 

func (membrane_value *Membrane_value) FromString(input string) (err error)

func (*Membrane_value) ToCodeString 

func (membrane_value *Membrane_value) ToCodeString() (res string)

func (Membrane_value) ToString 

func (membrane_value Membrane_value) ToString() (res string)

Utility function for Membrane_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Metal 

type Metal struct {
	Name  string
	Value *Metal_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_pictogram_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchMetal 

func CopyBranchMetal(mapOrigCopy map[any]any, metalFrom *Metal) (metalTo *Metal)

func (*Metal) Checkout 

func (metal *Metal) Checkout(stage *StageStruct) *Metal

Checkout metal to the back repo (if it is already staged)

func (*Metal) Commit 

func (metal *Metal) Commit(stage *StageStruct) *Metal

commit metal to the back repo (if it is already staged)

func (*Metal) CommitVoid 

func (metal *Metal) CommitVoid(stage *StageStruct)

func (*Metal) CopyBasicFields 

func (from *Metal) CopyBasicFields(to *Metal)

func (*Metal) GetName 

func (metal *Metal) GetName() (res string)

for satisfaction of GongStruct interface

func (*Metal) Stage 

func (metal *Metal) Stage(stage *StageStruct) *Metal

Stage puts metal to the model stage

func (*Metal) Unstage 

func (metal *Metal) Unstage(stage *StageStruct) *Metal

Unstage removes metal off the model stage

func (*Metal) UnstageVoid 

func (metal *Metal) UnstageVoid(stage *StageStruct)

UnstageVoid removes metal off the model stage

type Metal_WOP 

type Metal_WOP struct {
	// insertion point
	Name string
}

type Metal_value 

type Metal_value string
const (
	Metal_valueAgogo Metal_value = "agogo"

	Metal_valueAlmglocken Metal_value = "almglocken"

	Metal_valueBell Metal_value = "bell"

	Metal_valueBellplate Metal_value = "bell plate"

	Metal_valueBelltree Metal_value = "bell tree"

	Metal_valueBrakedrum Metal_value = "brake drum"

	Metal_valueCencerro Metal_value = "cencerro"

	Metal_valueChainrattle Metal_value = "chain rattle"

	Metal_valueChinesecymbal Metal_value = "Chinese cymbal"

	Metal_valueCowbell Metal_value = "cowbell"

	Metal_valueCrashcymbals Metal_value = "crash cymbals"

	Metal_valueCrotale Metal_value = "crotale"

	Metal_valueCymbaltongs Metal_value = "cymbal tongs"

	Metal_valueDomedgong Metal_value = "domed gong"

	Metal_valueFingercymbals Metal_value = "finger cymbals"

	Metal_valueFlexatone Metal_value = "flexatone"

	Metal_valueGong Metal_value = "gong"

	Metal_valueHi_hat Metal_value = "hi-hat"

	Metal_valueHigh_hatcymbals Metal_value = "high-hat cymbals"

	Metal_valueHandbell Metal_value = "handbell"

	Metal_valueJawharp Metal_value = "jaw harp"

	Metal_valueJinglebells Metal_value = "jingle bells"

	Metal_valueMusicalsaw Metal_value = "musical saw"

	Metal_valueShellbells Metal_value = "shell bells"

	Metal_valueSistrum Metal_value = "sistrum"

	Metal_valueSizzlecymbal Metal_value = "sizzle cymbal"

	Metal_valueSleighbells Metal_value = "sleigh bells"

	Metal_valueSuspendedcymbal Metal_value = "suspended cymbal"

	Metal_valueTamtam Metal_value = "tam tam"

	Metal_valueTamtamwithbeater Metal_value = "tam tam with beater"

	Metal_valueTriangle Metal_value = "triangle"

	Metal_valueVietnamesehat Metal_value = "Vietnamese hat"
)

func (Metal_value) CodeValues 

func (metal_value Metal_value) CodeValues() (res []string)

func (Metal_value) Codes 

func (metal_value Metal_value) Codes() (res []string)

func (*Metal_value) FromCodeString 

func (metal_value *Metal_value) FromCodeString(input string) (err error)

func (*Metal_value) FromString 

func (metal_value *Metal_value) FromString(input string) (err error)

func (*Metal_value) ToCodeString 

func (metal_value *Metal_value) ToCodeString() (res string)

func (Metal_value) ToString 

func (metal_value Metal_value) ToString() (res string)

Utility function for Metal_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Metronome 

type Metronome struct {
	Name        string
	Parentheses *Yes_no `xml:"parentheses,attr,omitempty" json:"parentheses,omitempty"`
}

func CopyBranchMetronome 

func CopyBranchMetronome(mapOrigCopy map[any]any, metronomeFrom *Metronome) (metronomeTo *Metronome)

func (*Metronome) Checkout 

func (metronome *Metronome) Checkout(stage *StageStruct) *Metronome

Checkout metronome to the back repo (if it is already staged)

func (*Metronome) Commit 

func (metronome *Metronome) Commit(stage *StageStruct) *Metronome

commit metronome to the back repo (if it is already staged)

func (*Metronome) CommitVoid 

func (metronome *Metronome) CommitVoid(stage *StageStruct)

func (*Metronome) CopyBasicFields 

func (from *Metronome) CopyBasicFields(to *Metronome)

func (*Metronome) GetName 

func (metronome *Metronome) GetName() (res string)

for satisfaction of GongStruct interface

func (*Metronome) Stage 

func (metronome *Metronome) Stage(stage *StageStruct) *Metronome

Stage puts metronome to the model stage

func (*Metronome) Unstage 

func (metronome *Metronome) Unstage(stage *StageStruct) *Metronome

Unstage removes metronome off the model stage

func (*Metronome) UnstageVoid 

func (metronome *Metronome) UnstageVoid(stage *StageStruct)

UnstageVoid removes metronome off the model stage

type Metronome_WOP 

type Metronome_WOP struct {
	// insertion point
	Name string
}

type Metronome_beam 

type Metronome_beam struct {
	Name  string
	Value *Beam_value `xml:",chardata" json:"-,"`

	Number *Beam_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchMetronome_beam 

func CopyBranchMetronome_beam(mapOrigCopy map[any]any, metronome_beamFrom *Metronome_beam) (metronome_beamTo *Metronome_beam)

func (*Metronome_beam) Checkout 

func (metronome_beam *Metronome_beam) Checkout(stage *StageStruct) *Metronome_beam

Checkout metronome_beam to the back repo (if it is already staged)

func (*Metronome_beam) Commit 

func (metronome_beam *Metronome_beam) Commit(stage *StageStruct) *Metronome_beam

commit metronome_beam to the back repo (if it is already staged)

func (*Metronome_beam) CommitVoid 

func (metronome_beam *Metronome_beam) CommitVoid(stage *StageStruct)

func (*Metronome_beam) CopyBasicFields 

func (from *Metronome_beam) CopyBasicFields(to *Metronome_beam)

func (*Metronome_beam) GetName 

func (metronome_beam *Metronome_beam) GetName() (res string)

for satisfaction of GongStruct interface

func (*Metronome_beam) Stage 

func (metronome_beam *Metronome_beam) Stage(stage *StageStruct) *Metronome_beam

Stage puts metronome_beam to the model stage

func (*Metronome_beam) Unstage 

func (metronome_beam *Metronome_beam) Unstage(stage *StageStruct) *Metronome_beam

Unstage removes metronome_beam off the model stage

func (*Metronome_beam) UnstageVoid 

func (metronome_beam *Metronome_beam) UnstageVoid(stage *StageStruct)

UnstageVoid removes metronome_beam off the model stage

type Metronome_beam_WOP 

type Metronome_beam_WOP struct {
	// insertion point
	Name string
}

type Metronome_note 

type Metronome_note struct {
	Name string

	// The metronome-type element works like the type element in
	// defining metric relationships.
	Metronome_type *Note_type_value `xml:"metronome-type,omitempty" json:"metronome-type,omitempty"`

	// The metronome-dot element works like the dot element in
	// defining metric relationships.
	Metronome_dot []*Empty `xml:"metronome-dot,omitempty" json:"metronome-dot,omitempty"`

	Metronome_beam []*Metronome_beam `xml:"metronome-beam,omitempty" json:"metronome-beam,omitempty"`

	Metronome_tied *Metronome_tied `xml:"metronome-tied,omitempty" json:"metronome-tied,omitempty"`

	Metronome_tuplet *Metronome_tuplet `xml:"metronome-tuplet,omitempty" json:"metronome-tuplet,omitempty"`
}

func CopyBranchMetronome_note 

func CopyBranchMetronome_note(mapOrigCopy map[any]any, metronome_noteFrom *Metronome_note) (metronome_noteTo *Metronome_note)

func (*Metronome_note) Checkout 

func (metronome_note *Metronome_note) Checkout(stage *StageStruct) *Metronome_note

Checkout metronome_note to the back repo (if it is already staged)

func (*Metronome_note) Commit 

func (metronome_note *Metronome_note) Commit(stage *StageStruct) *Metronome_note

commit metronome_note to the back repo (if it is already staged)

func (*Metronome_note) CommitVoid 

func (metronome_note *Metronome_note) CommitVoid(stage *StageStruct)

func (*Metronome_note) CopyBasicFields 

func (from *Metronome_note) CopyBasicFields(to *Metronome_note)

func (*Metronome_note) GetName 

func (metronome_note *Metronome_note) GetName() (res string)

for satisfaction of GongStruct interface

func (*Metronome_note) Stage 

func (metronome_note *Metronome_note) Stage(stage *StageStruct) *Metronome_note

Stage puts metronome_note to the model stage

func (*Metronome_note) Unstage 

func (metronome_note *Metronome_note) Unstage(stage *StageStruct) *Metronome_note

Unstage removes metronome_note off the model stage

func (*Metronome_note) UnstageVoid 

func (metronome_note *Metronome_note) UnstageVoid(stage *StageStruct)

UnstageVoid removes metronome_note off the model stage

type Metronome_note_WOP 

type Metronome_note_WOP struct {
	// insertion point
	Name string
}

type Metronome_tied 

type Metronome_tied struct {
	Name string
	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchMetronome_tied 

func CopyBranchMetronome_tied(mapOrigCopy map[any]any, metronome_tiedFrom *Metronome_tied) (metronome_tiedTo *Metronome_tied)

func (*Metronome_tied) Checkout 

func (metronome_tied *Metronome_tied) Checkout(stage *StageStruct) *Metronome_tied

Checkout metronome_tied to the back repo (if it is already staged)

func (*Metronome_tied) Commit 

func (metronome_tied *Metronome_tied) Commit(stage *StageStruct) *Metronome_tied

commit metronome_tied to the back repo (if it is already staged)

func (*Metronome_tied) CommitVoid 

func (metronome_tied *Metronome_tied) CommitVoid(stage *StageStruct)

func (*Metronome_tied) CopyBasicFields 

func (from *Metronome_tied) CopyBasicFields(to *Metronome_tied)

func (*Metronome_tied) GetName 

func (metronome_tied *Metronome_tied) GetName() (res string)

for satisfaction of GongStruct interface

func (*Metronome_tied) Stage 

func (metronome_tied *Metronome_tied) Stage(stage *StageStruct) *Metronome_tied

Stage puts metronome_tied to the model stage

func (*Metronome_tied) Unstage 

func (metronome_tied *Metronome_tied) Unstage(stage *StageStruct) *Metronome_tied

Unstage removes metronome_tied off the model stage

func (*Metronome_tied) UnstageVoid 

func (metronome_tied *Metronome_tied) UnstageVoid(stage *StageStruct)

UnstageVoid removes metronome_tied off the model stage

type Metronome_tied_WOP 

type Metronome_tied_WOP struct {
	// insertion point
	Name string
}

type Metronome_tuplet 

type Metronome_tuplet struct {
	Name string
	*Time_modification

	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Bracket *Yes_no `xml:"bracket,attr,omitempty" json:"bracket,omitempty"`

	Show_number *Show_tuplet `xml:"show-number,attr,omitempty" json:"show-number,omitempty"`
}

func CopyBranchMetronome_tuplet 

func CopyBranchMetronome_tuplet(mapOrigCopy map[any]any, metronome_tupletFrom *Metronome_tuplet) (metronome_tupletTo *Metronome_tuplet)

func (*Metronome_tuplet) Checkout 

func (metronome_tuplet *Metronome_tuplet) Checkout(stage *StageStruct) *Metronome_tuplet

Checkout metronome_tuplet to the back repo (if it is already staged)

func (*Metronome_tuplet) Commit 

func (metronome_tuplet *Metronome_tuplet) Commit(stage *StageStruct) *Metronome_tuplet

commit metronome_tuplet to the back repo (if it is already staged)

func (*Metronome_tuplet) CommitVoid 

func (metronome_tuplet *Metronome_tuplet) CommitVoid(stage *StageStruct)

func (*Metronome_tuplet) CopyBasicFields 

func (from *Metronome_tuplet) CopyBasicFields(to *Metronome_tuplet)

func (*Metronome_tuplet) GetName 

func (metronome_tuplet *Metronome_tuplet) GetName() (res string)

for satisfaction of GongStruct interface

func (*Metronome_tuplet) Stage 

func (metronome_tuplet *Metronome_tuplet) Stage(stage *StageStruct) *Metronome_tuplet

Stage puts metronome_tuplet to the model stage

func (*Metronome_tuplet) Unstage 

func (metronome_tuplet *Metronome_tuplet) Unstage(stage *StageStruct) *Metronome_tuplet

Unstage removes metronome_tuplet off the model stage

func (*Metronome_tuplet) UnstageVoid 

func (metronome_tuplet *Metronome_tuplet) UnstageVoid(stage *StageStruct)

UnstageVoid removes metronome_tuplet off the model stage

type Metronome_tuplet_WOP 

type Metronome_tuplet_WOP struct {
	// insertion point
	Name string
}

type Midi_128 

type Midi_128 PositiveInteger

type Midi_16 

type Midi_16 PositiveInteger

type Midi_16384 

type Midi_16384 PositiveInteger

type Midi_device 

type Midi_device struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Port *Midi_16 `xml:"port,attr,omitempty" json:"port,omitempty"`

	Id *IDREF `xml:"id,attr,omitempty" json:"id,omitempty"`
}

func CopyBranchMidi_device 

func CopyBranchMidi_device(mapOrigCopy map[any]any, midi_deviceFrom *Midi_device) (midi_deviceTo *Midi_device)

func (*Midi_device) Checkout 

func (midi_device *Midi_device) Checkout(stage *StageStruct) *Midi_device

Checkout midi_device to the back repo (if it is already staged)

func (*Midi_device) Commit 

func (midi_device *Midi_device) Commit(stage *StageStruct) *Midi_device

commit midi_device to the back repo (if it is already staged)

func (*Midi_device) CommitVoid 

func (midi_device *Midi_device) CommitVoid(stage *StageStruct)

func (*Midi_device) CopyBasicFields 

func (from *Midi_device) CopyBasicFields(to *Midi_device)

func (*Midi_device) GetName 

func (midi_device *Midi_device) GetName() (res string)

for satisfaction of GongStruct interface

func (*Midi_device) Stage 

func (midi_device *Midi_device) Stage(stage *StageStruct) *Midi_device

Stage puts midi_device to the model stage

func (*Midi_device) Unstage 

func (midi_device *Midi_device) Unstage(stage *StageStruct) *Midi_device

Unstage removes midi_device off the model stage

func (*Midi_device) UnstageVoid 

func (midi_device *Midi_device) UnstageVoid(stage *StageStruct)

UnstageVoid removes midi_device off the model stage

type Midi_device_WOP 

type Midi_device_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Midi_instrument 

type Midi_instrument struct {
	Name string

	// The midi-channel element specifies a MIDI 1.0 channel numbers
	// ranging from 1 to 16.
	Midi_channel *Midi_16 `xml:"midi-channel,omitempty" json:"midi-channel,omitempty"`

	// The midi-name element corresponds to a ProgramName meta-event
	// within a Standard MIDI File.
	Midi_name string `xml:"midi-name,omitempty" json:"midi-name,omitempty"`

	// The midi-bank element specifies a MIDI 1.0 bank number ranging
	// from 1 to 16,384.
	Midi_bank *Midi_16384 `xml:"midi-bank,omitempty" json:"midi-bank,omitempty"`

	// The midi-program element specifies a MIDI 1.0 program number
	// ranging from 1 to 128.
	Midi_program *Midi_128 `xml:"midi-program,omitempty" json:"midi-program,omitempty"`

	// For unpitched instruments, the midi-unpitched element
	// specifies a MIDI 1.0 note number ranging from 1 to 128. It is usually used
	// with MIDI banks for percussion. Note that MIDI 1.0 note numbers are
	// generally specified from 0 to 127 rather than the 1 to 128 numbering used in
	// this element.
	Midi_unpitched *Midi_128 `xml:"midi-unpitched,omitempty" json:"midi-unpitched,omitempty"`

	// The volume element value is a percentage of the maximum
	// ranging from 0 to 100, with decimal values allowed. This corresponds to a
	// scaling value for the MIDI 1.0 channel volume controller.
	Volume *Percent `xml:"volume,omitempty" json:"volume,omitempty"`

	// The pan and elevation elements allow placing of sound in a 3-D
	// space relative to the listener. Both are expressed in degrees ranging from
	// -180 to 180. For pan, 0 is straight ahead, -90 is hard left, 90 is hard
	// right, and -180 and 180 are directly behind the listener.
	Pan *Rotation_degrees `xml:"pan,omitempty" json:"pan,omitempty"`

	// The elevation and pan elements allow placing of sound in a 3-D
	// space relative to the listener. Both are expressed in degrees ranging from
	// -180 to 180. For elevation, 0 is level with the listener, 90 is directly
	// above, and -90 is directly below.
	Elevation *Rotation_degrees `xml:"elevation,omitempty" json:"elevation,omitempty"`

	Id *IDREF `xml:"id,attr,omitempty" json:"id,omitempty"`
}

func CopyBranchMidi_instrument 

func CopyBranchMidi_instrument(mapOrigCopy map[any]any, midi_instrumentFrom *Midi_instrument) (midi_instrumentTo *Midi_instrument)

func (*Midi_instrument) Checkout 

func (midi_instrument *Midi_instrument) Checkout(stage *StageStruct) *Midi_instrument

Checkout midi_instrument to the back repo (if it is already staged)

func (*Midi_instrument) Commit 

func (midi_instrument *Midi_instrument) Commit(stage *StageStruct) *Midi_instrument

commit midi_instrument to the back repo (if it is already staged)

func (*Midi_instrument) CommitVoid 

func (midi_instrument *Midi_instrument) CommitVoid(stage *StageStruct)

func (*Midi_instrument) CopyBasicFields 

func (from *Midi_instrument) CopyBasicFields(to *Midi_instrument)

func (*Midi_instrument) GetName 

func (midi_instrument *Midi_instrument) GetName() (res string)

for satisfaction of GongStruct interface

func (*Midi_instrument) Stage 

func (midi_instrument *Midi_instrument) Stage(stage *StageStruct) *Midi_instrument

Stage puts midi_instrument to the model stage

func (*Midi_instrument) Unstage 

func (midi_instrument *Midi_instrument) Unstage(stage *StageStruct) *Midi_instrument

Unstage removes midi_instrument off the model stage

func (*Midi_instrument) UnstageVoid 

func (midi_instrument *Midi_instrument) UnstageVoid(stage *StageStruct)

UnstageVoid removes midi_instrument off the model stage

type Midi_instrument_WOP 

type Midi_instrument_WOP struct {
	// insertion point
	Name      string
	Midi_name string
}

type Millimeters 

type Millimeters float64

type Milliseconds 

type Milliseconds uint32

type Miscellaneous 

type Miscellaneous struct {
	Name                string
	Miscellaneous_field []*Miscellaneous_field `xml:"miscellaneous-field,omitempty" json:"miscellaneous-field,omitempty"`
}

func CopyBranchMiscellaneous 

func CopyBranchMiscellaneous(mapOrigCopy map[any]any, miscellaneousFrom *Miscellaneous) (miscellaneousTo *Miscellaneous)

func (*Miscellaneous) Checkout 

func (miscellaneous *Miscellaneous) Checkout(stage *StageStruct) *Miscellaneous

Checkout miscellaneous to the back repo (if it is already staged)

func (*Miscellaneous) Commit 

func (miscellaneous *Miscellaneous) Commit(stage *StageStruct) *Miscellaneous

commit miscellaneous to the back repo (if it is already staged)

func (*Miscellaneous) CommitVoid 

func (miscellaneous *Miscellaneous) CommitVoid(stage *StageStruct)

func (*Miscellaneous) CopyBasicFields 

func (from *Miscellaneous) CopyBasicFields(to *Miscellaneous)

func (*Miscellaneous) GetName 

func (miscellaneous *Miscellaneous) GetName() (res string)

for satisfaction of GongStruct interface

func (*Miscellaneous) Stage 

func (miscellaneous *Miscellaneous) Stage(stage *StageStruct) *Miscellaneous

Stage puts miscellaneous to the model stage

func (*Miscellaneous) Unstage 

func (miscellaneous *Miscellaneous) Unstage(stage *StageStruct) *Miscellaneous

Unstage removes miscellaneous off the model stage

func (*Miscellaneous) UnstageVoid 

func (miscellaneous *Miscellaneous) UnstageVoid(stage *StageStruct)

UnstageVoid removes miscellaneous off the model stage

type Miscellaneous_WOP 

type Miscellaneous_WOP struct {
	// insertion point
	Name string
}

type Miscellaneous_field 

type Miscellaneous_field struct {
	Value string `xml:",chardata" json:"-,"`

	Name string `xml:"name,attr,omitempty" json:"name,omitempty"`
}

func CopyBranchMiscellaneous_field 

func CopyBranchMiscellaneous_field(mapOrigCopy map[any]any, miscellaneous_fieldFrom *Miscellaneous_field) (miscellaneous_fieldTo *Miscellaneous_field)

func (*Miscellaneous_field) Checkout 

func (miscellaneous_field *Miscellaneous_field) Checkout(stage *StageStruct) *Miscellaneous_field

Checkout miscellaneous_field to the back repo (if it is already staged)

func (*Miscellaneous_field) Commit 

func (miscellaneous_field *Miscellaneous_field) Commit(stage *StageStruct) *Miscellaneous_field

commit miscellaneous_field to the back repo (if it is already staged)

func (*Miscellaneous_field) CommitVoid 

func (miscellaneous_field *Miscellaneous_field) CommitVoid(stage *StageStruct)

func (*Miscellaneous_field) CopyBasicFields 

func (from *Miscellaneous_field) CopyBasicFields(to *Miscellaneous_field)

func (*Miscellaneous_field) GetName 

func (miscellaneous_field *Miscellaneous_field) GetName() (res string)

for satisfaction of GongStruct interface

func (*Miscellaneous_field) Stage 

func (miscellaneous_field *Miscellaneous_field) Stage(stage *StageStruct) *Miscellaneous_field

Stage puts miscellaneous_field to the model stage

func (*Miscellaneous_field) Unstage 

func (miscellaneous_field *Miscellaneous_field) Unstage(stage *StageStruct) *Miscellaneous_field

Unstage removes miscellaneous_field off the model stage

func (*Miscellaneous_field) UnstageVoid 

func (miscellaneous_field *Miscellaneous_field) UnstageVoid(stage *StageStruct)

UnstageVoid removes miscellaneous_field off the model stage

type Miscellaneous_field_WOP 

type Miscellaneous_field_WOP struct {
	// insertion point
	Value string
	Name  string
}

type Mode 

type Mode string

func (Mode) CodeValues 

func (mode Mode) CodeValues() (res []string)

func (Mode) Codes 

func (mode Mode) Codes() (res []string)

func (*Mode) FromCodeString 

func (mode *Mode) FromCodeString(input string) (err error)

func (*Mode) FromString 

func (mode *Mode) FromString(input string) (err error)

func (*Mode) ToCodeString 

func (mode *Mode) ToCodeString() (res string)

func (Mode) ToString 

func (mode Mode) ToString() (res string)

Utility function for Mode if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Mordent 

type Mordent struct {
	Name string
	*Empty_trill_sound

	Long *Yes_no `xml:"long,attr,omitempty" json:"long,omitempty"`

	Approach *Above_below `xml:"approach,attr,omitempty" json:"approach,omitempty"`

	Departure *Above_below `xml:"departure,attr,omitempty" json:"departure,omitempty"`
}

func CopyBranchMordent 

func CopyBranchMordent(mapOrigCopy map[any]any, mordentFrom *Mordent) (mordentTo *Mordent)

func (*Mordent) Checkout 

func (mordent *Mordent) Checkout(stage *StageStruct) *Mordent

Checkout mordent to the back repo (if it is already staged)

func (*Mordent) Commit 

func (mordent *Mordent) Commit(stage *StageStruct) *Mordent

commit mordent to the back repo (if it is already staged)

func (*Mordent) CommitVoid 

func (mordent *Mordent) CommitVoid(stage *StageStruct)

func (*Mordent) CopyBasicFields 

func (from *Mordent) CopyBasicFields(to *Mordent)

func (*Mordent) GetName 

func (mordent *Mordent) GetName() (res string)

for satisfaction of GongStruct interface

func (*Mordent) Stage 

func (mordent *Mordent) Stage(stage *StageStruct) *Mordent

Stage puts mordent to the model stage

func (*Mordent) Unstage 

func (mordent *Mordent) Unstage(stage *StageStruct) *Mordent

Unstage removes mordent off the model stage

func (*Mordent) UnstageVoid 

func (mordent *Mordent) UnstageVoid(stage *StageStruct)

UnstageVoid removes mordent off the model stage

type Mordent_WOP 

type Mordent_WOP struct {
	// insertion point
	Name string
}

type Multiple_rest 

type Multiple_rest struct {
	Name  string
	Value *PositiveInteger `xml:",chardata" json:"-,"`

	Use_symbols *Yes_no `xml:"use-symbols,attr,omitempty" json:"use-symbols,omitempty"`
}

func CopyBranchMultiple_rest 

func CopyBranchMultiple_rest(mapOrigCopy map[any]any, multiple_restFrom *Multiple_rest) (multiple_restTo *Multiple_rest)

func (*Multiple_rest) Checkout 

func (multiple_rest *Multiple_rest) Checkout(stage *StageStruct) *Multiple_rest

Checkout multiple_rest to the back repo (if it is already staged)

func (*Multiple_rest) Commit 

func (multiple_rest *Multiple_rest) Commit(stage *StageStruct) *Multiple_rest

commit multiple_rest to the back repo (if it is already staged)

func (*Multiple_rest) CommitVoid 

func (multiple_rest *Multiple_rest) CommitVoid(stage *StageStruct)

func (*Multiple_rest) CopyBasicFields 

func (from *Multiple_rest) CopyBasicFields(to *Multiple_rest)

func (*Multiple_rest) GetName 

func (multiple_rest *Multiple_rest) GetName() (res string)

for satisfaction of GongStruct interface

func (*Multiple_rest) Stage 

func (multiple_rest *Multiple_rest) Stage(stage *StageStruct) *Multiple_rest

Stage puts multiple_rest to the model stage

func (*Multiple_rest) Unstage 

func (multiple_rest *Multiple_rest) Unstage(stage *StageStruct) *Multiple_rest

Unstage removes multiple_rest off the model stage

func (*Multiple_rest) UnstageVoid 

func (multiple_rest *Multiple_rest) UnstageVoid(stage *StageStruct)

UnstageVoid removes multiple_rest off the model stage

type Multiple_rest_WOP 

type Multiple_rest_WOP struct {
	// insertion point
	Name string
}

type Mute 

type Mute string
const (
	MuteOn Mute = "on"

	MuteOff Mute = "off"

	MuteStraight Mute = "straight"

	MuteCup Mute = "cup"

	MuteHarmon_no_stem Mute = "harmon-no-stem"

	MuteHarmon_stem Mute = "harmon-stem"

	MuteBucket Mute = "bucket"

	MutePlunger Mute = "plunger"

	MuteHat Mute = "hat"

	MuteSolotone Mute = "solotone"

	MutePractice Mute = "practice"

	MuteStop_mute Mute = "stop-mute"

	MuteStop_hand Mute = "stop-hand"

	MuteEcho Mute = "echo"

	MutePalm Mute = "palm"
)

func (Mute) CodeValues 

func (mute Mute) CodeValues() (res []string)

func (Mute) Codes 

func (mute Mute) Codes() (res []string)

func (*Mute) FromCodeString 

func (mute *Mute) FromCodeString(input string) (err error)

func (*Mute) FromString 

func (mute *Mute) FromString(input string) (err error)

func (*Mute) ToCodeString 

func (mute *Mute) ToCodeString() (res string)

func (Mute) ToString 

func (mute Mute) ToString() (res string)

Utility function for Mute if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type NCName 

type NCName string

func (NCName) CodeValues 

func (ncname NCName) CodeValues() (res []string)

func (NCName) Codes 

func (ncname NCName) Codes() (res []string)

func (*NCName) FromCodeString 

func (ncname *NCName) FromCodeString(input string) (err error)

func (*NCName) FromString 

func (ncname *NCName) FromString(input string) (err error)

func (*NCName) ToCodeString 

func (ncname *NCName) ToCodeString() (res string)

func (NCName) ToString 

func (ncname NCName) ToString() (res string)

Utility function for NCName if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type NMTOKEN 

type NMTOKEN string

func (NMTOKEN) CodeValues 

func (nmtoken NMTOKEN) CodeValues() (res []string)

func (NMTOKEN) Codes 

func (nmtoken NMTOKEN) Codes() (res []string)

func (*NMTOKEN) FromCodeString 

func (nmtoken *NMTOKEN) FromCodeString(input string) (err error)

func (*NMTOKEN) FromString 

func (nmtoken *NMTOKEN) FromString(input string) (err error)

func (*NMTOKEN) ToCodeString 

func (nmtoken *NMTOKEN) ToCodeString() (res string)

func (NMTOKEN) ToString 

func (nmtoken NMTOKEN) ToString() (res string)

Utility function for NMTOKEN if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Name_display 

type Name_display struct {
	Name         string
	Display_text *Formatted_text `xml:"display-text,omitempty" json:"display-text,omitempty"`

	Accidental_text *Accidental_text `xml:"accidental-text,omitempty" json:"accidental-text,omitempty"`
}

func CopyBranchName_display 

func CopyBranchName_display(mapOrigCopy map[any]any, name_displayFrom *Name_display) (name_displayTo *Name_display)

func (*Name_display) Checkout 

func (name_display *Name_display) Checkout(stage *StageStruct) *Name_display

Checkout name_display to the back repo (if it is already staged)

func (*Name_display) Commit 

func (name_display *Name_display) Commit(stage *StageStruct) *Name_display

commit name_display to the back repo (if it is already staged)

func (*Name_display) CommitVoid 

func (name_display *Name_display) CommitVoid(stage *StageStruct)

func (*Name_display) CopyBasicFields 

func (from *Name_display) CopyBasicFields(to *Name_display)

func (*Name_display) GetName 

func (name_display *Name_display) GetName() (res string)

for satisfaction of GongStruct interface

func (*Name_display) Stage 

func (name_display *Name_display) Stage(stage *StageStruct) *Name_display

Stage puts name_display to the model stage

func (*Name_display) Unstage 

func (name_display *Name_display) Unstage(stage *StageStruct) *Name_display

Unstage removes name_display off the model stage

func (*Name_display) UnstageVoid 

func (name_display *Name_display) UnstageVoid(stage *StageStruct)

UnstageVoid removes name_display off the model stage

type Name_display_WOP 

type Name_display_WOP struct {
	// insertion point
	Name string
}

type Non_arpeggiate 

type Non_arpeggiate struct {
	Name string
	Type *Top_bottom `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchNon_arpeggiate 

func CopyBranchNon_arpeggiate(mapOrigCopy map[any]any, non_arpeggiateFrom *Non_arpeggiate) (non_arpeggiateTo *Non_arpeggiate)

func (*Non_arpeggiate) Checkout 

func (non_arpeggiate *Non_arpeggiate) Checkout(stage *StageStruct) *Non_arpeggiate

Checkout non_arpeggiate to the back repo (if it is already staged)

func (*Non_arpeggiate) Commit 

func (non_arpeggiate *Non_arpeggiate) Commit(stage *StageStruct) *Non_arpeggiate

commit non_arpeggiate to the back repo (if it is already staged)

func (*Non_arpeggiate) CommitVoid 

func (non_arpeggiate *Non_arpeggiate) CommitVoid(stage *StageStruct)

func (*Non_arpeggiate) CopyBasicFields 

func (from *Non_arpeggiate) CopyBasicFields(to *Non_arpeggiate)

func (*Non_arpeggiate) GetName 

func (non_arpeggiate *Non_arpeggiate) GetName() (res string)

for satisfaction of GongStruct interface

func (*Non_arpeggiate) Stage 

func (non_arpeggiate *Non_arpeggiate) Stage(stage *StageStruct) *Non_arpeggiate

Stage puts non_arpeggiate to the model stage

func (*Non_arpeggiate) Unstage 

func (non_arpeggiate *Non_arpeggiate) Unstage(stage *StageStruct) *Non_arpeggiate

Unstage removes non_arpeggiate off the model stage

func (*Non_arpeggiate) UnstageVoid 

func (non_arpeggiate *Non_arpeggiate) UnstageVoid(stage *StageStruct)

UnstageVoid removes non_arpeggiate off the model stage

type Non_arpeggiate_WOP 

type Non_arpeggiate_WOP struct {
	// insertion point
	Name string
}

type Non_negative_decimal 

type Non_negative_decimal float64

type Notations 

type Notations struct {
	Name string
	Tied *Tied `xml:"tied,omitempty" json:"tied,omitempty"`

	Slur *Slur `xml:"slur,omitempty" json:"slur,omitempty"`

	Tuplet *Tuplet `xml:"tuplet,omitempty" json:"tuplet,omitempty"`

	Glissando *Glissando `xml:"glissando,omitempty" json:"glissando,omitempty"`

	Slide *Slide `xml:"slide,omitempty" json:"slide,omitempty"`

	Ornaments *Ornaments `xml:"ornaments,omitempty" json:"ornaments,omitempty"`

	Technical *Technical `xml:"technical,omitempty" json:"technical,omitempty"`

	Articulations *Articulations `xml:"articulations,omitempty" json:"articulations,omitempty"`

	Dynamics *Dynamics `xml:"dynamics,omitempty" json:"dynamics,omitempty"`

	Fermata *Fermata `xml:"fermata,omitempty" json:"fermata,omitempty"`

	Arpeggiate *Arpeggiate `xml:"arpeggiate,omitempty" json:"arpeggiate,omitempty"`

	Non_arpeggiate *Non_arpeggiate `xml:"non-arpeggiate,omitempty" json:"non-arpeggiate,omitempty"`

	Accidental_mark *Accidental_mark `xml:"accidental-mark,omitempty" json:"accidental-mark,omitempty"`

	Other_notation *Other_notation `xml:"other-notation,omitempty" json:"other-notation,omitempty"`
}

func CopyBranchNotations 

func CopyBranchNotations(mapOrigCopy map[any]any, notationsFrom *Notations) (notationsTo *Notations)

func (*Notations) Checkout 

func (notations *Notations) Checkout(stage *StageStruct) *Notations

Checkout notations to the back repo (if it is already staged)

func (*Notations) Commit 

func (notations *Notations) Commit(stage *StageStruct) *Notations

commit notations to the back repo (if it is already staged)

func (*Notations) CommitVoid 

func (notations *Notations) CommitVoid(stage *StageStruct)

func (*Notations) CopyBasicFields 

func (from *Notations) CopyBasicFields(to *Notations)

func (*Notations) GetName 

func (notations *Notations) GetName() (res string)

for satisfaction of GongStruct interface

func (*Notations) Stage 

func (notations *Notations) Stage(stage *StageStruct) *Notations

Stage puts notations to the model stage

func (*Notations) Unstage 

func (notations *Notations) Unstage(stage *StageStruct) *Notations

Unstage removes notations off the model stage

func (*Notations) UnstageVoid 

func (notations *Notations) UnstageVoid(stage *StageStruct)

UnstageVoid removes notations off the model stage

type Notations_WOP 

type Notations_WOP struct {
	// insertion point
	Name string
}

type Note 

type Note struct {
	Name       string
	Instrument []*Instrument `xml:"instrument,omitempty" json:"instrument,omitempty"`

	Type_ *Note_type `xml:"type,omitempty" json:"type,omitempty"`

	// One dot element is used for each dot of prolongation. The
	// placement attribute is used to specify whether the dot should appear above
	// or below the staff line. It is ignored for notes that appear on a staff
	// space.
	Dot []*Empty_placement `xml:"dot,omitempty" json:"dot,omitempty"`

	Accidental *Accidental `xml:"accidental,omitempty" json:"accidental,omitempty"`

	Time_modification *Time_modification `xml:"time-modification,omitempty" json:"time-modification,omitempty"`

	Stem *Stem `xml:"stem,omitempty" json:"stem,omitempty"`

	Notehead *Notehead `xml:"notehead,omitempty" json:"notehead,omitempty"`

	Notehead_text *Notehead_text `xml:"notehead-text,omitempty" json:"notehead-text,omitempty"`

	Beam *Beam `xml:"beam,omitempty" json:"beam,omitempty"`

	Notations []*Notations `xml:"notations,omitempty" json:"notations,omitempty"`

	Lyric []*Lyric `xml:"lyric,omitempty" json:"lyric,omitempty"`

	Play *Play `xml:"play,omitempty" json:"play,omitempty"`

	Listen *Listen `xml:"listen,omitempty" json:"listen,omitempty"`

	Print_leger *Yes_no `xml:"print-leger,attr,omitempty" json:"print-leger,omitempty"`

	Dynamics *Non_negative_decimal `xml:"dynamics,attr,omitempty" json:"dynamics,omitempty"`

	End_dynamics *Non_negative_decimal `xml:"end-dynamics,attr,omitempty" json:"end-dynamics,omitempty"`

	Attack *Divisions `xml:"attack,attr,omitempty" json:"attack,omitempty"`

	Release *Divisions `xml:"release,attr,omitempty" json:"release,omitempty"`

	Time_only *Time_only `xml:"time-only,attr,omitempty" json:"time-only,omitempty"`

	Pizzicato *Yes_no `xml:"pizzicato,attr,omitempty" json:"pizzicato,omitempty"`
}

func CopyBranchNote 

func CopyBranchNote(mapOrigCopy map[any]any, noteFrom *Note) (noteTo *Note)

func (*Note) Checkout 

func (note *Note) Checkout(stage *StageStruct) *Note

Checkout note to the back repo (if it is already staged)

func (*Note) Commit 

func (note *Note) Commit(stage *StageStruct) *Note

commit note to the back repo (if it is already staged)

func (*Note) CommitVoid 

func (note *Note) CommitVoid(stage *StageStruct)

func (*Note) CopyBasicFields 

func (from *Note) CopyBasicFields(to *Note)

func (*Note) GetName 

func (note *Note) GetName() (res string)

for satisfaction of GongStruct interface

func (*Note) Stage 

func (note *Note) Stage(stage *StageStruct) *Note

Stage puts note to the model stage

func (*Note) Unstage 

func (note *Note) Unstage(stage *StageStruct) *Note

Unstage removes note off the model stage

func (*Note) UnstageVoid 

func (note *Note) UnstageVoid(stage *StageStruct)

UnstageVoid removes note off the model stage

type Note_WOP 

type Note_WOP struct {
	// insertion point
	Name string
}

type Note_size 

type Note_size struct {
	Name  string
	Value *Non_negative_decimal `xml:",chardata" json:"-,"`

	Type *Note_size_type `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchNote_size 

func CopyBranchNote_size(mapOrigCopy map[any]any, note_sizeFrom *Note_size) (note_sizeTo *Note_size)

func (*Note_size) Checkout 

func (note_size *Note_size) Checkout(stage *StageStruct) *Note_size

Checkout note_size to the back repo (if it is already staged)

func (*Note_size) Commit 

func (note_size *Note_size) Commit(stage *StageStruct) *Note_size

commit note_size to the back repo (if it is already staged)

func (*Note_size) CommitVoid 

func (note_size *Note_size) CommitVoid(stage *StageStruct)

func (*Note_size) CopyBasicFields 

func (from *Note_size) CopyBasicFields(to *Note_size)

func (*Note_size) GetName 

func (note_size *Note_size) GetName() (res string)

for satisfaction of GongStruct interface

func (*Note_size) Stage 

func (note_size *Note_size) Stage(stage *StageStruct) *Note_size

Stage puts note_size to the model stage

func (*Note_size) Unstage 

func (note_size *Note_size) Unstage(stage *StageStruct) *Note_size

Unstage removes note_size off the model stage

func (*Note_size) UnstageVoid 

func (note_size *Note_size) UnstageVoid(stage *StageStruct)

UnstageVoid removes note_size off the model stage

type Note_size_WOP 

type Note_size_WOP struct {
	// insertion point
	Name string
}

type Note_size_type 

type Note_size_type string
const (
	Note_size_typeCue Note_size_type = "cue"

	Note_size_typeGrace Note_size_type = "grace"

	Note_size_typeGrace_cue Note_size_type = "grace-cue"

	Note_size_typeLarge Note_size_type = "large"
)

func (Note_size_type) CodeValues 

func (note_size_type Note_size_type) CodeValues() (res []string)

func (Note_size_type) Codes 

func (note_size_type Note_size_type) Codes() (res []string)

func (*Note_size_type) FromCodeString 

func (note_size_type *Note_size_type) FromCodeString(input string) (err error)

func (*Note_size_type) FromString 

func (note_size_type *Note_size_type) FromString(input string) (err error)

func (*Note_size_type) ToCodeString 

func (note_size_type *Note_size_type) ToCodeString() (res string)

func (Note_size_type) ToString 

func (note_size_type Note_size_type) ToString() (res string)

Utility function for Note_size_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Note_type 

type Note_type struct {
	Name    string
	XMLName xml.Name `xml:" type"`

	Value *Note_type_value `xml:",chardata" json:"-,"`

	Size *Symbol_size `xml:"size,attr,omitempty" json:"size,omitempty"`
}

func CopyBranchNote_type 

func CopyBranchNote_type(mapOrigCopy map[any]any, note_typeFrom *Note_type) (note_typeTo *Note_type)

func (*Note_type) Checkout 

func (note_type *Note_type) Checkout(stage *StageStruct) *Note_type

Checkout note_type to the back repo (if it is already staged)

func (*Note_type) Commit 

func (note_type *Note_type) Commit(stage *StageStruct) *Note_type

commit note_type to the back repo (if it is already staged)

func (*Note_type) CommitVoid 

func (note_type *Note_type) CommitVoid(stage *StageStruct)

func (*Note_type) CopyBasicFields 

func (from *Note_type) CopyBasicFields(to *Note_type)

func (*Note_type) GetName 

func (note_type *Note_type) GetName() (res string)

for satisfaction of GongStruct interface

func (*Note_type) Stage 

func (note_type *Note_type) Stage(stage *StageStruct) *Note_type

Stage puts note_type to the model stage

func (*Note_type) Unstage 

func (note_type *Note_type) Unstage(stage *StageStruct) *Note_type

Unstage removes note_type off the model stage

func (*Note_type) UnstageVoid 

func (note_type *Note_type) UnstageVoid(stage *StageStruct)

UnstageVoid removes note_type off the model stage

type Note_type_WOP 

type Note_type_WOP struct {
	// insertion point
	Name string
}

type Note_type_value 

type Note_type_value string
const (
	Note_type_value1024th Note_type_value = "1024th"

	Note_type_value512th Note_type_value = "512th"

	Note_type_value256th Note_type_value = "256th"

	Note_type_value128th Note_type_value = "128th"

	Note_type_value64th Note_type_value = "64th"

	Note_type_value32nd Note_type_value = "32nd"

	Note_type_value16th Note_type_value = "16th"

	Note_type_valueEighth Note_type_value = "eighth"

	Note_type_valueQuarter Note_type_value = "quarter"

	Note_type_valueHalf Note_type_value = "half"

	Note_type_valueWhole Note_type_value = "whole"

	Note_type_valueBreve Note_type_value = "breve"

	Note_type_valueLong Note_type_value = "long"

	Note_type_valueMaxima Note_type_value = "maxima"
)

func (Note_type_value) CodeValues 

func (note_type_value Note_type_value) CodeValues() (res []string)

func (Note_type_value) Codes 

func (note_type_value Note_type_value) Codes() (res []string)

func (*Note_type_value) FromCodeString 

func (note_type_value *Note_type_value) FromCodeString(input string) (err error)

func (*Note_type_value) FromString 

func (note_type_value *Note_type_value) FromString(input string) (err error)

func (*Note_type_value) ToCodeString 

func (note_type_value *Note_type_value) ToCodeString() (res string)

func (Note_type_value) ToString 

func (note_type_value Note_type_value) ToString() (res string)

Utility function for Note_type_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Notehead 

type Notehead struct {
	Name  string
	Value *Notehead_value `xml:",chardata" json:"-,"`

	Filled *Yes_no `xml:"filled,attr,omitempty" json:"filled,omitempty"`

	Parentheses *Yes_no `xml:"parentheses,attr,omitempty" json:"parentheses,omitempty"`
}

func CopyBranchNotehead 

func CopyBranchNotehead(mapOrigCopy map[any]any, noteheadFrom *Notehead) (noteheadTo *Notehead)

func (*Notehead) Checkout 

func (notehead *Notehead) Checkout(stage *StageStruct) *Notehead

Checkout notehead to the back repo (if it is already staged)

func (*Notehead) Commit 

func (notehead *Notehead) Commit(stage *StageStruct) *Notehead

commit notehead to the back repo (if it is already staged)

func (*Notehead) CommitVoid 

func (notehead *Notehead) CommitVoid(stage *StageStruct)

func (*Notehead) CopyBasicFields 

func (from *Notehead) CopyBasicFields(to *Notehead)

func (*Notehead) GetName 

func (notehead *Notehead) GetName() (res string)

for satisfaction of GongStruct interface

func (*Notehead) Stage 

func (notehead *Notehead) Stage(stage *StageStruct) *Notehead

Stage puts notehead to the model stage

func (*Notehead) Unstage 

func (notehead *Notehead) Unstage(stage *StageStruct) *Notehead

Unstage removes notehead off the model stage

func (*Notehead) UnstageVoid 

func (notehead *Notehead) UnstageVoid(stage *StageStruct)

UnstageVoid removes notehead off the model stage

type Notehead_WOP 

type Notehead_WOP struct {
	// insertion point
	Name string
}

type Notehead_text 

type Notehead_text struct {
	Name         string
	Display_text *Formatted_text `xml:"display-text,omitempty" json:"display-text,omitempty"`

	Accidental_text *Accidental_text `xml:"accidental-text,omitempty" json:"accidental-text,omitempty"`
}

func CopyBranchNotehead_text 

func CopyBranchNotehead_text(mapOrigCopy map[any]any, notehead_textFrom *Notehead_text) (notehead_textTo *Notehead_text)

func (*Notehead_text) Checkout 

func (notehead_text *Notehead_text) Checkout(stage *StageStruct) *Notehead_text

Checkout notehead_text to the back repo (if it is already staged)

func (*Notehead_text) Commit 

func (notehead_text *Notehead_text) Commit(stage *StageStruct) *Notehead_text

commit notehead_text to the back repo (if it is already staged)

func (*Notehead_text) CommitVoid 

func (notehead_text *Notehead_text) CommitVoid(stage *StageStruct)

func (*Notehead_text) CopyBasicFields 

func (from *Notehead_text) CopyBasicFields(to *Notehead_text)

func (*Notehead_text) GetName 

func (notehead_text *Notehead_text) GetName() (res string)

for satisfaction of GongStruct interface

func (*Notehead_text) Stage 

func (notehead_text *Notehead_text) Stage(stage *StageStruct) *Notehead_text

Stage puts notehead_text to the model stage

func (*Notehead_text) Unstage 

func (notehead_text *Notehead_text) Unstage(stage *StageStruct) *Notehead_text

Unstage removes notehead_text off the model stage

func (*Notehead_text) UnstageVoid 

func (notehead_text *Notehead_text) UnstageVoid(stage *StageStruct)

UnstageVoid removes notehead_text off the model stage

type Notehead_text_WOP 

type Notehead_text_WOP struct {
	// insertion point
	Name string
}

type Notehead_value 

type Notehead_value string
const (
	Notehead_valueSlash Notehead_value = "slash"

	Notehead_valueTriangle Notehead_value = "triangle"

	Notehead_valueDiamond Notehead_value = "diamond"

	Notehead_valueSquare Notehead_value = "square"

	Notehead_valueCross Notehead_value = "cross"

	Notehead_valueX Notehead_value = "x"

	Notehead_valueCircle_x Notehead_value = "circle-x"

	Notehead_valueInvertedtriangle Notehead_value = "inverted triangle"

	Notehead_valueArrowdown Notehead_value = "arrow down"

	Notehead_valueArrowup Notehead_value = "arrow up"

	Notehead_valueCircled Notehead_value = "circled"

	Notehead_valueSlashed Notehead_value = "slashed"

	Notehead_valueBackslashed Notehead_value = "back slashed"

	Notehead_valueNormal Notehead_value = "normal"

	Notehead_valueCluster Notehead_value = "cluster"

	Notehead_valueCircledot Notehead_value = "circle dot"

	Notehead_valueLefttriangle Notehead_value = "left triangle"

	Notehead_valueRectangle Notehead_value = "rectangle"

	Notehead_valueNone Notehead_value = "none"

	Notehead_valueDo Notehead_value = "do"

	Notehead_valueRe Notehead_value = "re"

	Notehead_valueMi Notehead_value = "mi"

	Notehead_valueFa Notehead_value = "fa"

	Notehead_valueFaup Notehead_value = "fa up"

	Notehead_valueSo Notehead_value = "so"

	Notehead_valueLa Notehead_value = "la"

	Notehead_valueTi Notehead_value = "ti"

	Notehead_valueOther Notehead_value = "other"
)

func (Notehead_value) CodeValues 

func (notehead_value Notehead_value) CodeValues() (res []string)

func (Notehead_value) Codes 

func (notehead_value Notehead_value) Codes() (res []string)

func (*Notehead_value) FromCodeString 

func (notehead_value *Notehead_value) FromCodeString(input string) (err error)

func (*Notehead_value) FromString 

func (notehead_value *Notehead_value) FromString(input string) (err error)

func (*Notehead_value) ToCodeString 

func (notehead_value *Notehead_value) ToCodeString() (res string)

func (Notehead_value) ToString 

func (notehead_value Notehead_value) ToString() (res string)

Utility function for Notehead_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Number_level 

type Number_level PositiveInteger

type Number_of_lines 

type Number_of_lines uint32

type Number_or_normal 

type Number_or_normal string

func (Number_or_normal) CodeValues 

func (number_or_normal Number_or_normal) CodeValues() (res []string)

func (Number_or_normal) Codes 

func (number_or_normal Number_or_normal) Codes() (res []string)

func (*Number_or_normal) FromCodeString 

func (number_or_normal *Number_or_normal) FromCodeString(input string) (err error)

func (*Number_or_normal) FromString 

func (number_or_normal *Number_or_normal) FromString(input string) (err error)

func (*Number_or_normal) ToCodeString 

func (number_or_normal *Number_or_normal) ToCodeString() (res string)

func (Number_or_normal) ToString 

func (number_or_normal Number_or_normal) ToString() (res string)

Utility function for Number_or_normal if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Numeral 

type Numeral struct {
	Name         string
	Numeral_root *Numeral_root `xml:"numeral-root,omitempty" json:"numeral-root,omitempty"`

	// The numeral-alter element represents an alteration to the
	// numeral-root, similar to the alter element for a pitch. The print-object
	// attribute can be used to hide an alteration in cases such as when the
	// MusicXML encoding of a 6 or 7 numeral-root in a minor key requires an
	// alteration that is not displayed. The location attribute indicates whether
	// the alteration should appear to the left or the right of the numeral-root.
	// It is left by default.
	Numeral_alter *Harmony_alter `xml:"numeral-alter,omitempty" json:"numeral-alter,omitempty"`

	Numeral_key *Numeral_key `xml:"numeral-key,omitempty" json:"numeral-key,omitempty"`
}

func CopyBranchNumeral 

func CopyBranchNumeral(mapOrigCopy map[any]any, numeralFrom *Numeral) (numeralTo *Numeral)

func (*Numeral) Checkout 

func (numeral *Numeral) Checkout(stage *StageStruct) *Numeral

Checkout numeral to the back repo (if it is already staged)

func (*Numeral) Commit 

func (numeral *Numeral) Commit(stage *StageStruct) *Numeral

commit numeral to the back repo (if it is already staged)

func (*Numeral) CommitVoid 

func (numeral *Numeral) CommitVoid(stage *StageStruct)

func (*Numeral) CopyBasicFields 

func (from *Numeral) CopyBasicFields(to *Numeral)

func (*Numeral) GetName 

func (numeral *Numeral) GetName() (res string)

for satisfaction of GongStruct interface

func (*Numeral) Stage 

func (numeral *Numeral) Stage(stage *StageStruct) *Numeral

Stage puts numeral to the model stage

func (*Numeral) Unstage 

func (numeral *Numeral) Unstage(stage *StageStruct) *Numeral

Unstage removes numeral off the model stage

func (*Numeral) UnstageVoid 

func (numeral *Numeral) UnstageVoid(stage *StageStruct)

UnstageVoid removes numeral off the model stage

type Numeral_WOP 

type Numeral_WOP struct {
	// insertion point
	Name string
}

type Numeral_key 

type Numeral_key struct {
	Name           string
	Numeral_fifths *Fifths `xml:"numeral-fifths,omitempty" json:"numeral-fifths,omitempty"`

	Numeral_mode *Numeral_mode `xml:"numeral-mode,omitempty" json:"numeral-mode,omitempty"`
}

func CopyBranchNumeral_key 

func CopyBranchNumeral_key(mapOrigCopy map[any]any, numeral_keyFrom *Numeral_key) (numeral_keyTo *Numeral_key)

func (*Numeral_key) Checkout 

func (numeral_key *Numeral_key) Checkout(stage *StageStruct) *Numeral_key

Checkout numeral_key to the back repo (if it is already staged)

func (*Numeral_key) Commit 

func (numeral_key *Numeral_key) Commit(stage *StageStruct) *Numeral_key

commit numeral_key to the back repo (if it is already staged)

func (*Numeral_key) CommitVoid 

func (numeral_key *Numeral_key) CommitVoid(stage *StageStruct)

func (*Numeral_key) CopyBasicFields 

func (from *Numeral_key) CopyBasicFields(to *Numeral_key)

func (*Numeral_key) GetName 

func (numeral_key *Numeral_key) GetName() (res string)

for satisfaction of GongStruct interface

func (*Numeral_key) Stage 

func (numeral_key *Numeral_key) Stage(stage *StageStruct) *Numeral_key

Stage puts numeral_key to the model stage

func (*Numeral_key) Unstage 

func (numeral_key *Numeral_key) Unstage(stage *StageStruct) *Numeral_key

Unstage removes numeral_key off the model stage

func (*Numeral_key) UnstageVoid 

func (numeral_key *Numeral_key) UnstageVoid(stage *StageStruct)

UnstageVoid removes numeral_key off the model stage

type Numeral_key_WOP 

type Numeral_key_WOP struct {
	// insertion point
	Name string
}

type Numeral_mode 

type Numeral_mode string
const (
	Numeral_modeMajor Numeral_mode = "major"

	Numeral_modeMinor Numeral_mode = "minor"

	Numeral_modeNaturalminor Numeral_mode = "natural minor"

	Numeral_modeMelodicminor Numeral_mode = "melodic minor"

	Numeral_modeHarmonicminor Numeral_mode = "harmonic minor"
)

func (Numeral_mode) CodeValues 

func (numeral_mode Numeral_mode) CodeValues() (res []string)

func (Numeral_mode) Codes 

func (numeral_mode Numeral_mode) Codes() (res []string)

func (*Numeral_mode) FromCodeString 

func (numeral_mode *Numeral_mode) FromCodeString(input string) (err error)

func (*Numeral_mode) FromString 

func (numeral_mode *Numeral_mode) FromString(input string) (err error)

func (*Numeral_mode) ToCodeString 

func (numeral_mode *Numeral_mode) ToCodeString() (res string)

func (Numeral_mode) ToString 

func (numeral_mode Numeral_mode) ToString() (res string)

Utility function for Numeral_mode if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Numeral_root 

type Numeral_root struct {
	Name  string
	Value *Numeral_value `xml:",chardata" json:"-,"`

	Text string `xml:"text,attr,omitempty" json:"text,omitempty"`
}

func CopyBranchNumeral_root 

func CopyBranchNumeral_root(mapOrigCopy map[any]any, numeral_rootFrom *Numeral_root) (numeral_rootTo *Numeral_root)

func (*Numeral_root) Checkout 

func (numeral_root *Numeral_root) Checkout(stage *StageStruct) *Numeral_root

Checkout numeral_root to the back repo (if it is already staged)

func (*Numeral_root) Commit 

func (numeral_root *Numeral_root) Commit(stage *StageStruct) *Numeral_root

commit numeral_root to the back repo (if it is already staged)

func (*Numeral_root) CommitVoid 

func (numeral_root *Numeral_root) CommitVoid(stage *StageStruct)

func (*Numeral_root) CopyBasicFields 

func (from *Numeral_root) CopyBasicFields(to *Numeral_root)

func (*Numeral_root) GetName 

func (numeral_root *Numeral_root) GetName() (res string)

for satisfaction of GongStruct interface

func (*Numeral_root) Stage 

func (numeral_root *Numeral_root) Stage(stage *StageStruct) *Numeral_root

Stage puts numeral_root to the model stage

func (*Numeral_root) Unstage 

func (numeral_root *Numeral_root) Unstage(stage *StageStruct) *Numeral_root

Unstage removes numeral_root off the model stage

func (*Numeral_root) UnstageVoid 

func (numeral_root *Numeral_root) UnstageVoid(stage *StageStruct)

UnstageVoid removes numeral_root off the model stage

type Numeral_root_WOP 

type Numeral_root_WOP struct {
	// insertion point
	Name string
	Text string
}

type Numeral_value 

type Numeral_value PositiveInteger

type Octave 

type Octave int32

type Octave_shift 

type Octave_shift struct {
	Name string
	Type *Up_down_stop_continue `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`

	Size *PositiveInteger `xml:"size,attr,omitempty" json:"size,omitempty"`
}

func CopyBranchOctave_shift 

func CopyBranchOctave_shift(mapOrigCopy map[any]any, octave_shiftFrom *Octave_shift) (octave_shiftTo *Octave_shift)

func (*Octave_shift) Checkout 

func (octave_shift *Octave_shift) Checkout(stage *StageStruct) *Octave_shift

Checkout octave_shift to the back repo (if it is already staged)

func (*Octave_shift) Commit 

func (octave_shift *Octave_shift) Commit(stage *StageStruct) *Octave_shift

commit octave_shift to the back repo (if it is already staged)

func (*Octave_shift) CommitVoid 

func (octave_shift *Octave_shift) CommitVoid(stage *StageStruct)

func (*Octave_shift) CopyBasicFields 

func (from *Octave_shift) CopyBasicFields(to *Octave_shift)

func (*Octave_shift) GetName 

func (octave_shift *Octave_shift) GetName() (res string)

for satisfaction of GongStruct interface

func (*Octave_shift) Stage 

func (octave_shift *Octave_shift) Stage(stage *StageStruct) *Octave_shift

Stage puts octave_shift to the model stage

func (*Octave_shift) Unstage 

func (octave_shift *Octave_shift) Unstage(stage *StageStruct) *Octave_shift

Unstage removes octave_shift off the model stage

func (*Octave_shift) UnstageVoid 

func (octave_shift *Octave_shift) UnstageVoid(stage *StageStruct)

UnstageVoid removes octave_shift off the model stage

type Octave_shift_WOP 

type Octave_shift_WOP struct {
	// insertion point
	Name string
}

type Offset 

type Offset struct {
	Name  string
	Value *Divisions `xml:",chardata" json:"-,"`

	Sound *Yes_no `xml:"sound,attr,omitempty" json:"sound,omitempty"`
}

func CopyBranchOffset 

func CopyBranchOffset(mapOrigCopy map[any]any, offsetFrom *Offset) (offsetTo *Offset)

func (*Offset) Checkout 

func (offset *Offset) Checkout(stage *StageStruct) *Offset

Checkout offset to the back repo (if it is already staged)

func (*Offset) Commit 

func (offset *Offset) Commit(stage *StageStruct) *Offset

commit offset to the back repo (if it is already staged)

func (*Offset) CommitVoid 

func (offset *Offset) CommitVoid(stage *StageStruct)

func (*Offset) CopyBasicFields 

func (from *Offset) CopyBasicFields(to *Offset)

func (*Offset) GetName 

func (offset *Offset) GetName() (res string)

for satisfaction of GongStruct interface

func (*Offset) Stage 

func (offset *Offset) Stage(stage *StageStruct) *Offset

Stage puts offset to the model stage

func (*Offset) Unstage 

func (offset *Offset) Unstage(stage *StageStruct) *Offset

Unstage removes offset off the model stage

func (*Offset) UnstageVoid 

func (offset *Offset) UnstageVoid(stage *StageStruct)

UnstageVoid removes offset off the model stage

type Offset_WOP 

type Offset_WOP struct {
	// insertion point
	Name string
}

type OnAfterCreateInterface 

type OnAfterCreateInterface[Type Gongstruct] interface {
	OnAfterCreate(stage *StageStruct,
		instance *Type)
}

OnAfterCreateInterface callback when an instance is updated from the front

type OnAfterDeleteInterface 

type OnAfterDeleteInterface[Type Gongstruct] interface {
	OnAfterDelete(stage *StageStruct,
		staged, front *Type)
}

OnAfterDeleteInterface callback when an instance is updated from the front

type OnAfterReadInterface 

type OnAfterReadInterface[Type Gongstruct] interface {
	OnAfterRead(stage *StageStruct,
		instance *Type)
}

OnAfterReadInterface callback when an instance is updated from the front

type OnAfterUpdateInterface 

type OnAfterUpdateInterface[Type Gongstruct] interface {
	OnAfterUpdate(stage *StageStruct, old, new *Type)
}

OnAfterUpdateInterface callback when an instance is updated from the front

type OnInitCommitInterface 

type OnInitCommitInterface interface {
	BeforeCommit(stage *StageStruct)
}

type On_off 

type On_off string
const (
	On_offOn On_off = "on"

	On_offOff On_off = "off"
)

func (On_off) CodeValues 

func (on_off On_off) CodeValues() (res []string)

func (On_off) Codes 

func (on_off On_off) Codes() (res []string)

func (*On_off) FromCodeString 

func (on_off *On_off) FromCodeString(input string) (err error)

func (*On_off) FromString 

func (on_off *On_off) FromString(input string) (err error)

func (*On_off) ToCodeString 

func (on_off *On_off) ToCodeString() (res string)

func (On_off) ToString 

func (on_off On_off) ToString() (res string)

Utility function for On_off if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Opus 

type Opus struct {
	Name string
}

func CopyBranchOpus 

func CopyBranchOpus(mapOrigCopy map[any]any, opusFrom *Opus) (opusTo *Opus)

func (*Opus) Checkout 

func (opus *Opus) Checkout(stage *StageStruct) *Opus

Checkout opus to the back repo (if it is already staged)

func (*Opus) Commit 

func (opus *Opus) Commit(stage *StageStruct) *Opus

commit opus to the back repo (if it is already staged)

func (*Opus) CommitVoid 

func (opus *Opus) CommitVoid(stage *StageStruct)

func (*Opus) CopyBasicFields 

func (from *Opus) CopyBasicFields(to *Opus)

func (*Opus) GetName 

func (opus *Opus) GetName() (res string)

for satisfaction of GongStruct interface

func (*Opus) Stage 

func (opus *Opus) Stage(stage *StageStruct) *Opus

Stage puts opus to the model stage

func (*Opus) Unstage 

func (opus *Opus) Unstage(stage *StageStruct) *Opus

Unstage removes opus off the model stage

func (*Opus) UnstageVoid 

func (opus *Opus) UnstageVoid(stage *StageStruct)

UnstageVoid removes opus off the model stage

type Opus_WOP 

type Opus_WOP struct {
	// insertion point
	Name string
}

type Ornaments 

type Ornaments struct {
	Name            string
	Accidental_mark []*Accidental_mark `xml:"accidental-mark,omitempty" json:"accidental-mark,omitempty"`

	// The trill-mark element represents the trill-mark symbol.
	Trill_mark *Empty_trill_sound `xml:"trill-mark,omitempty" json:"trill-mark,omitempty"`

	// The turn element is the normal turn shape which goes up
	// then down.
	Turn *Horizontal_turn `xml:"turn,omitempty" json:"turn,omitempty"`

	// The delayed-turn element indicates a normal turn that is
	// delayed until the end of the current note.
	Delayed_turn *Horizontal_turn `xml:"delayed-turn,omitempty" json:"delayed-turn,omitempty"`

	// The inverted-turn element has the shape which goes down
	// and then up.
	Inverted_turn *Horizontal_turn `xml:"inverted-turn,omitempty" json:"inverted-turn,omitempty"`

	// The delayed-inverted-turn element indicates an inverted
	// turn that is delayed until the end of the current note.
	Delayed_inverted_turn *Horizontal_turn `xml:"delayed-inverted-turn,omitempty" json:"delayed-inverted-turn,omitempty"`

	// The vertical-turn element has the turn symbol shape
	// arranged vertically going from upper left to lower right.
	Vertical_turn *Empty_trill_sound `xml:"vertical-turn,omitempty" json:"vertical-turn,omitempty"`

	// The inverted-vertical-turn element has the turn symbol
	// shape arranged vertically going from upper right to lower left.
	Inverted_vertical_turn *Empty_trill_sound `xml:"inverted-vertical-turn,omitempty" json:"inverted-vertical-turn,omitempty"`

	// The shake element has a similar appearance to an
	// inverted-mordent element.
	Shake *Empty_trill_sound `xml:"shake,omitempty" json:"shake,omitempty"`

	Wavy_line *Wavy_line `xml:"wavy-line,omitempty" json:"wavy-line,omitempty"`

	// The mordent element represents the sign with the vertical
	// line. The choice of which mordent sign is inverted differs between
	// MusicXML and SMuFL. The long attribute is "no" by default.
	Mordent *Mordent `xml:"mordent,omitempty" json:"mordent,omitempty"`

	// The inverted-mordent element represents the sign without
	// the vertical line. The choice of which mordent is inverted differs
	// between MusicXML and SMuFL. The long attribute is "no" by default.
	Inverted_mordent *Mordent `xml:"inverted-mordent,omitempty" json:"inverted-mordent,omitempty"`

	// The name for this ornament is based on the German, to
	// avoid confusion with the more common slide element defined earlier.
	Schleifer *Empty_placement `xml:"schleifer,omitempty" json:"schleifer,omitempty"`

	Tremolo *Tremolo `xml:"tremolo,omitempty" json:"tremolo,omitempty"`

	// The haydn element represents the Haydn ornament. This is
	// defined in SMuFL as ornamentHaydn.
	Haydn *Empty_trill_sound `xml:"haydn,omitempty" json:"haydn,omitempty"`

	// The other-ornament element is used to define any ornaments
	// not yet in the MusicXML format. The smufl attribute can be used to
	// specify a particular ornament, allowing application interoperability
	// without requiring every SMuFL ornament to have a MusicXML element
	// equivalent. Using the other-ornament element without the smufl attribute
	// allows for extended representation, though without application
	// interoperability.
	Other_ornament *Other_placement_text `xml:"other-ornament,omitempty" json:"other-ornament,omitempty"`
}

func CopyBranchOrnaments 

func CopyBranchOrnaments(mapOrigCopy map[any]any, ornamentsFrom *Ornaments) (ornamentsTo *Ornaments)

func (*Ornaments) Checkout 

func (ornaments *Ornaments) Checkout(stage *StageStruct) *Ornaments

Checkout ornaments to the back repo (if it is already staged)

func (*Ornaments) Commit 

func (ornaments *Ornaments) Commit(stage *StageStruct) *Ornaments

commit ornaments to the back repo (if it is already staged)

func (*Ornaments) CommitVoid 

func (ornaments *Ornaments) CommitVoid(stage *StageStruct)

func (*Ornaments) CopyBasicFields 

func (from *Ornaments) CopyBasicFields(to *Ornaments)

func (*Ornaments) GetName 

func (ornaments *Ornaments) GetName() (res string)

for satisfaction of GongStruct interface

func (*Ornaments) Stage 

func (ornaments *Ornaments) Stage(stage *StageStruct) *Ornaments

Stage puts ornaments to the model stage

func (*Ornaments) Unstage 

func (ornaments *Ornaments) Unstage(stage *StageStruct) *Ornaments

Unstage removes ornaments off the model stage

func (*Ornaments) UnstageVoid 

func (ornaments *Ornaments) UnstageVoid(stage *StageStruct)

UnstageVoid removes ornaments off the model stage

type Ornaments_WOP 

type Ornaments_WOP struct {
	// insertion point
	Name string
}

type Other_appearance 

type Other_appearance struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type string `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchOther_appearance 

func CopyBranchOther_appearance(mapOrigCopy map[any]any, other_appearanceFrom *Other_appearance) (other_appearanceTo *Other_appearance)

func (*Other_appearance) Checkout 

func (other_appearance *Other_appearance) Checkout(stage *StageStruct) *Other_appearance

Checkout other_appearance to the back repo (if it is already staged)

func (*Other_appearance) Commit 

func (other_appearance *Other_appearance) Commit(stage *StageStruct) *Other_appearance

commit other_appearance to the back repo (if it is already staged)

func (*Other_appearance) CommitVoid 

func (other_appearance *Other_appearance) CommitVoid(stage *StageStruct)

func (*Other_appearance) CopyBasicFields 

func (from *Other_appearance) CopyBasicFields(to *Other_appearance)

func (*Other_appearance) GetName 

func (other_appearance *Other_appearance) GetName() (res string)

for satisfaction of GongStruct interface

func (*Other_appearance) Stage 

func (other_appearance *Other_appearance) Stage(stage *StageStruct) *Other_appearance

Stage puts other_appearance to the model stage

func (*Other_appearance) Unstage 

func (other_appearance *Other_appearance) Unstage(stage *StageStruct) *Other_appearance

Unstage removes other_appearance off the model stage

func (*Other_appearance) UnstageVoid 

func (other_appearance *Other_appearance) UnstageVoid(stage *StageStruct)

UnstageVoid removes other_appearance off the model stage

type Other_appearance_WOP 

type Other_appearance_WOP struct {
	// insertion point
	Name  string
	Value string
	Type  string
}

type Other_direction 

type Other_direction string

func (Other_direction) CodeValues 

func (other_direction Other_direction) CodeValues() (res []string)

func (Other_direction) Codes 

func (other_direction Other_direction) Codes() (res []string)

func (*Other_direction) FromCodeString 

func (other_direction *Other_direction) FromCodeString(input string) (err error)

func (*Other_direction) FromString 

func (other_direction *Other_direction) FromString(input string) (err error)

func (*Other_direction) ToCodeString 

func (other_direction *Other_direction) ToCodeString() (res string)

func (Other_direction) ToString 

func (other_direction Other_direction) ToString() (res string)

Utility function for Other_direction if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Other_listening 

type Other_listening struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type string `xml:"type,attr,omitempty" json:"type,omitempty"`

	Player *IDREF `xml:"player,attr,omitempty" json:"player,omitempty"`

	Time_only *Time_only `xml:"time-only,attr,omitempty" json:"time-only,omitempty"`
}

func CopyBranchOther_listening 

func CopyBranchOther_listening(mapOrigCopy map[any]any, other_listeningFrom *Other_listening) (other_listeningTo *Other_listening)

func (*Other_listening) Checkout 

func (other_listening *Other_listening) Checkout(stage *StageStruct) *Other_listening

Checkout other_listening to the back repo (if it is already staged)

func (*Other_listening) Commit 

func (other_listening *Other_listening) Commit(stage *StageStruct) *Other_listening

commit other_listening to the back repo (if it is already staged)

func (*Other_listening) CommitVoid 

func (other_listening *Other_listening) CommitVoid(stage *StageStruct)

func (*Other_listening) CopyBasicFields 

func (from *Other_listening) CopyBasicFields(to *Other_listening)

func (*Other_listening) GetName 

func (other_listening *Other_listening) GetName() (res string)

for satisfaction of GongStruct interface

func (*Other_listening) Stage 

func (other_listening *Other_listening) Stage(stage *StageStruct) *Other_listening

Stage puts other_listening to the model stage

func (*Other_listening) Unstage 

func (other_listening *Other_listening) Unstage(stage *StageStruct) *Other_listening

Unstage removes other_listening off the model stage

func (*Other_listening) UnstageVoid 

func (other_listening *Other_listening) UnstageVoid(stage *StageStruct)

UnstageVoid removes other_listening off the model stage

type Other_listening_WOP 

type Other_listening_WOP struct {
	// insertion point
	Name  string
	Value string
	Type  string
}

type Other_notation 

type Other_notation struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type *Start_stop_single `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchOther_notation 

func CopyBranchOther_notation(mapOrigCopy map[any]any, other_notationFrom *Other_notation) (other_notationTo *Other_notation)

func (*Other_notation) Checkout 

func (other_notation *Other_notation) Checkout(stage *StageStruct) *Other_notation

Checkout other_notation to the back repo (if it is already staged)

func (*Other_notation) Commit 

func (other_notation *Other_notation) Commit(stage *StageStruct) *Other_notation

commit other_notation to the back repo (if it is already staged)

func (*Other_notation) CommitVoid 

func (other_notation *Other_notation) CommitVoid(stage *StageStruct)

func (*Other_notation) CopyBasicFields 

func (from *Other_notation) CopyBasicFields(to *Other_notation)

func (*Other_notation) GetName 

func (other_notation *Other_notation) GetName() (res string)

for satisfaction of GongStruct interface

func (*Other_notation) Stage 

func (other_notation *Other_notation) Stage(stage *StageStruct) *Other_notation

Stage puts other_notation to the model stage

func (*Other_notation) Unstage 

func (other_notation *Other_notation) Unstage(stage *StageStruct) *Other_notation

Unstage removes other_notation off the model stage

func (*Other_notation) UnstageVoid 

func (other_notation *Other_notation) UnstageVoid(stage *StageStruct)

UnstageVoid removes other_notation off the model stage

type Other_notation_WOP 

type Other_notation_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Other_placement_text 

type Other_placement_text string

func (Other_placement_text) CodeValues 

func (other_placement_text Other_placement_text) CodeValues() (res []string)

func (Other_placement_text) Codes 

func (other_placement_text Other_placement_text) Codes() (res []string)

func (*Other_placement_text) FromCodeString 

func (other_placement_text *Other_placement_text) FromCodeString(input string) (err error)

func (*Other_placement_text) FromString 

func (other_placement_text *Other_placement_text) FromString(input string) (err error)

func (*Other_placement_text) ToCodeString 

func (other_placement_text *Other_placement_text) ToCodeString() (res string)

func (Other_placement_text) ToString 

func (other_placement_text Other_placement_text) ToString() (res string)

Utility function for Other_placement_text if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Other_play 

type Other_play struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type string `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchOther_play 

func CopyBranchOther_play(mapOrigCopy map[any]any, other_playFrom *Other_play) (other_playTo *Other_play)

func (*Other_play) Checkout 

func (other_play *Other_play) Checkout(stage *StageStruct) *Other_play

Checkout other_play to the back repo (if it is already staged)

func (*Other_play) Commit 

func (other_play *Other_play) Commit(stage *StageStruct) *Other_play

commit other_play to the back repo (if it is already staged)

func (*Other_play) CommitVoid 

func (other_play *Other_play) CommitVoid(stage *StageStruct)

func (*Other_play) CopyBasicFields 

func (from *Other_play) CopyBasicFields(to *Other_play)

func (*Other_play) GetName 

func (other_play *Other_play) GetName() (res string)

for satisfaction of GongStruct interface

func (*Other_play) Stage 

func (other_play *Other_play) Stage(stage *StageStruct) *Other_play

Stage puts other_play to the model stage

func (*Other_play) Unstage 

func (other_play *Other_play) Unstage(stage *StageStruct) *Other_play

Unstage removes other_play off the model stage

func (*Other_play) UnstageVoid 

func (other_play *Other_play) UnstageVoid(stage *StageStruct)

UnstageVoid removes other_play off the model stage

type Other_play_WOP 

type Other_play_WOP struct {
	// insertion point
	Name  string
	Value string
	Type  string
}

type Other_text 

type Other_text string

func (Other_text) CodeValues 

func (other_text Other_text) CodeValues() (res []string)

func (Other_text) Codes 

func (other_text Other_text) Codes() (res []string)

func (*Other_text) FromCodeString 

func (other_text *Other_text) FromCodeString(input string) (err error)

func (*Other_text) FromString 

func (other_text *Other_text) FromString(input string) (err error)

func (*Other_text) ToCodeString 

func (other_text *Other_text) ToCodeString() (res string)

func (Other_text) ToString 

func (other_text Other_text) ToString() (res string)

Utility function for Other_text if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Over_under 

type Over_under string
const (
	Over_underOver Over_under = "over"

	Over_underUnder Over_under = "under"
)

func (Over_under) CodeValues 

func (over_under Over_under) CodeValues() (res []string)

func (Over_under) Codes 

func (over_under Over_under) Codes() (res []string)

func (*Over_under) FromCodeString 

func (over_under *Over_under) FromCodeString(input string) (err error)

func (*Over_under) FromString 

func (over_under *Over_under) FromString(input string) (err error)

func (*Over_under) ToCodeString 

func (over_under *Over_under) ToCodeString() (res string)

func (Over_under) ToString 

func (over_under Over_under) ToString() (res string)

Utility function for Over_under if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Page_layout 

type Page_layout struct {
	Name         string
	Page_margins *Page_margins `xml:"page-margins,omitempty" json:"page-margins,omitempty"`
}

func CopyBranchPage_layout 

func CopyBranchPage_layout(mapOrigCopy map[any]any, page_layoutFrom *Page_layout) (page_layoutTo *Page_layout)

func (*Page_layout) Checkout 

func (page_layout *Page_layout) Checkout(stage *StageStruct) *Page_layout

Checkout page_layout to the back repo (if it is already staged)

func (*Page_layout) Commit 

func (page_layout *Page_layout) Commit(stage *StageStruct) *Page_layout

commit page_layout to the back repo (if it is already staged)

func (*Page_layout) CommitVoid 

func (page_layout *Page_layout) CommitVoid(stage *StageStruct)

func (*Page_layout) CopyBasicFields 

func (from *Page_layout) CopyBasicFields(to *Page_layout)

func (*Page_layout) GetName 

func (page_layout *Page_layout) GetName() (res string)

for satisfaction of GongStruct interface

func (*Page_layout) Stage 

func (page_layout *Page_layout) Stage(stage *StageStruct) *Page_layout

Stage puts page_layout to the model stage

func (*Page_layout) Unstage 

func (page_layout *Page_layout) Unstage(stage *StageStruct) *Page_layout

Unstage removes page_layout off the model stage

func (*Page_layout) UnstageVoid 

func (page_layout *Page_layout) UnstageVoid(stage *StageStruct)

UnstageVoid removes page_layout off the model stage

type Page_layout_WOP 

type Page_layout_WOP struct {
	// insertion point
	Name string
}

type Page_margins 

type Page_margins struct {
	Name string
	Type *Margin_type `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchPage_margins 

func CopyBranchPage_margins(mapOrigCopy map[any]any, page_marginsFrom *Page_margins) (page_marginsTo *Page_margins)

func (*Page_margins) Checkout 

func (page_margins *Page_margins) Checkout(stage *StageStruct) *Page_margins

Checkout page_margins to the back repo (if it is already staged)

func (*Page_margins) Commit 

func (page_margins *Page_margins) Commit(stage *StageStruct) *Page_margins

commit page_margins to the back repo (if it is already staged)

func (*Page_margins) CommitVoid 

func (page_margins *Page_margins) CommitVoid(stage *StageStruct)

func (*Page_margins) CopyBasicFields 

func (from *Page_margins) CopyBasicFields(to *Page_margins)

func (*Page_margins) GetName 

func (page_margins *Page_margins) GetName() (res string)

for satisfaction of GongStruct interface

func (*Page_margins) Stage 

func (page_margins *Page_margins) Stage(stage *StageStruct) *Page_margins

Stage puts page_margins to the model stage

func (*Page_margins) Unstage 

func (page_margins *Page_margins) Unstage(stage *StageStruct) *Page_margins

Unstage removes page_margins off the model stage

func (*Page_margins) UnstageVoid 

func (page_margins *Page_margins) UnstageVoid(stage *StageStruct)

UnstageVoid removes page_margins off the model stage

type Page_margins_WOP 

type Page_margins_WOP struct {
	// insertion point
	Name string
}

type Part_clef 

type Part_clef struct {
	Name string
}

func CopyBranchPart_clef 

func CopyBranchPart_clef(mapOrigCopy map[any]any, part_clefFrom *Part_clef) (part_clefTo *Part_clef)

func (*Part_clef) Checkout 

func (part_clef *Part_clef) Checkout(stage *StageStruct) *Part_clef

Checkout part_clef to the back repo (if it is already staged)

func (*Part_clef) Commit 

func (part_clef *Part_clef) Commit(stage *StageStruct) *Part_clef

commit part_clef to the back repo (if it is already staged)

func (*Part_clef) CommitVoid 

func (part_clef *Part_clef) CommitVoid(stage *StageStruct)

func (*Part_clef) CopyBasicFields 

func (from *Part_clef) CopyBasicFields(to *Part_clef)

func (*Part_clef) GetName 

func (part_clef *Part_clef) GetName() (res string)

for satisfaction of GongStruct interface

func (*Part_clef) Stage 

func (part_clef *Part_clef) Stage(stage *StageStruct) *Part_clef

Stage puts part_clef to the model stage

func (*Part_clef) Unstage 

func (part_clef *Part_clef) Unstage(stage *StageStruct) *Part_clef

Unstage removes part_clef off the model stage

func (*Part_clef) UnstageVoid 

func (part_clef *Part_clef) UnstageVoid(stage *StageStruct)

UnstageVoid removes part_clef off the model stage

type Part_clef_WOP 

type Part_clef_WOP struct {
	// insertion point
	Name string
}

type Part_group 

type Part_group struct {
	Name       string
	Group_name *Group_name `xml:"group-name,omitempty" json:"group-name,omitempty"`

	// Formatting specified in the group-name-display element
	// overrides formatting specified in the group-name element.
	Group_name_display *Name_display `xml:"group-name-display,omitempty" json:"group-name-display,omitempty"`

	Group_abbreviation *Group_name `xml:"group-abbreviation,omitempty" json:"group-abbreviation,omitempty"`

	// Formatting specified in the group-abbreviation-display element
	// overrides formatting specified in the group-abbreviation element.
	Group_abbreviation_display *Name_display `xml:"group-abbreviation-display,omitempty" json:"group-abbreviation-display,omitempty"`

	Group_symbol *Group_symbol `xml:"group-symbol,omitempty" json:"group-symbol,omitempty"`

	Group_barline *Group_barline `xml:"group-barline,omitempty" json:"group-barline,omitempty"`

	// The group-time element indicates that the displayed time
	// signatures should stretch across all parts and staves in the group.
	Group_time *Empty `xml:"group-time,omitempty" json:"group-time,omitempty"`

	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number string `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchPart_group 

func CopyBranchPart_group(mapOrigCopy map[any]any, part_groupFrom *Part_group) (part_groupTo *Part_group)

func (*Part_group) Checkout 

func (part_group *Part_group) Checkout(stage *StageStruct) *Part_group

Checkout part_group to the back repo (if it is already staged)

func (*Part_group) Commit 

func (part_group *Part_group) Commit(stage *StageStruct) *Part_group

commit part_group to the back repo (if it is already staged)

func (*Part_group) CommitVoid 

func (part_group *Part_group) CommitVoid(stage *StageStruct)

func (*Part_group) CopyBasicFields 

func (from *Part_group) CopyBasicFields(to *Part_group)

func (*Part_group) GetName 

func (part_group *Part_group) GetName() (res string)

for satisfaction of GongStruct interface

func (*Part_group) Stage 

func (part_group *Part_group) Stage(stage *StageStruct) *Part_group

Stage puts part_group to the model stage

func (*Part_group) Unstage 

func (part_group *Part_group) Unstage(stage *StageStruct) *Part_group

Unstage removes part_group off the model stage

func (*Part_group) UnstageVoid 

func (part_group *Part_group) UnstageVoid(stage *StageStruct)

UnstageVoid removes part_group off the model stage

type Part_group_WOP 

type Part_group_WOP struct {
	// insertion point
	Name   string
	Number string
}
type Part_link struct {
	Name            string
	Instrument_link []*Instrument_link `xml:"instrument-link,omitempty" json:"instrument-link,omitempty"`

	// Multiple part-link elements can reference different types of
	// linked documents, such as parts and condensed score. The optional group-link
	// elements identify the groups used in the linked document. The content of a
	// group-link element should match the content of a group element in the linked
	// document.
	Group_link []string `xml:"group-link,omitempty" json:"group-link,omitempty"`
}
func CopyBranchPart_link(mapOrigCopy map[any]any, part_linkFrom *Part_link) (part_linkTo *Part_link)

func (*Part_link) Checkout 

func (part_link *Part_link) Checkout(stage *StageStruct) *Part_link

Checkout part_link to the back repo (if it is already staged)

func (*Part_link) Commit 

func (part_link *Part_link) Commit(stage *StageStruct) *Part_link

commit part_link to the back repo (if it is already staged)

func (*Part_link) CommitVoid 

func (part_link *Part_link) CommitVoid(stage *StageStruct)

func (*Part_link) CopyBasicFields 

func (from *Part_link) CopyBasicFields(to *Part_link)

func (*Part_link) GetName 

func (part_link *Part_link) GetName() (res string)

for satisfaction of GongStruct interface

func (*Part_link) Stage 

func (part_link *Part_link) Stage(stage *StageStruct) *Part_link

Stage puts part_link to the model stage

func (*Part_link) Unstage 

func (part_link *Part_link) Unstage(stage *StageStruct) *Part_link

Unstage removes part_link off the model stage

func (*Part_link) UnstageVoid 

func (part_link *Part_link) UnstageVoid(stage *StageStruct)

UnstageVoid removes part_link off the model stage 

type Part_link_WOP struct {
	// insertion point
	Name string
}

type Part_list 

type Part_list struct {
	Name string
}

func CopyBranchPart_list 

func CopyBranchPart_list(mapOrigCopy map[any]any, part_listFrom *Part_list) (part_listTo *Part_list)

func (*Part_list) Checkout 

func (part_list *Part_list) Checkout(stage *StageStruct) *Part_list

Checkout part_list to the back repo (if it is already staged)

func (*Part_list) Commit 

func (part_list *Part_list) Commit(stage *StageStruct) *Part_list

commit part_list to the back repo (if it is already staged)

func (*Part_list) CommitVoid 

func (part_list *Part_list) CommitVoid(stage *StageStruct)

func (*Part_list) CopyBasicFields 

func (from *Part_list) CopyBasicFields(to *Part_list)

func (*Part_list) GetName 

func (part_list *Part_list) GetName() (res string)

for satisfaction of GongStruct interface

func (*Part_list) Stage 

func (part_list *Part_list) Stage(stage *StageStruct) *Part_list

Stage puts part_list to the model stage

func (*Part_list) Unstage 

func (part_list *Part_list) Unstage(stage *StageStruct) *Part_list

Unstage removes part_list off the model stage

func (*Part_list) UnstageVoid 

func (part_list *Part_list) UnstageVoid(stage *StageStruct)

UnstageVoid removes part_list off the model stage

type Part_list_WOP 

type Part_list_WOP struct {
	// insertion point
	Name string
}

type Part_name 

type Part_name string

func (Part_name) CodeValues 

func (part_name Part_name) CodeValues() (res []string)

func (Part_name) Codes 

func (part_name Part_name) Codes() (res []string)

func (*Part_name) FromCodeString 

func (part_name *Part_name) FromCodeString(input string) (err error)

func (*Part_name) FromString 

func (part_name *Part_name) FromString(input string) (err error)

func (*Part_name) ToCodeString 

func (part_name *Part_name) ToCodeString() (res string)

func (Part_name) ToString 

func (part_name Part_name) ToString() (res string)

Utility function for Part_name if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Part_symbol 

type Part_symbol struct {
	Name  string
	Value *Group_symbol_value `xml:",chardata" json:"-,"`

	Top_staff *Staff_number `xml:"top-staff,attr,omitempty" json:"top-staff,omitempty"`

	Bottom_staff *Staff_number `xml:"bottom-staff,attr,omitempty" json:"bottom-staff,omitempty"`
}

func CopyBranchPart_symbol 

func CopyBranchPart_symbol(mapOrigCopy map[any]any, part_symbolFrom *Part_symbol) (part_symbolTo *Part_symbol)

func (*Part_symbol) Checkout 

func (part_symbol *Part_symbol) Checkout(stage *StageStruct) *Part_symbol

Checkout part_symbol to the back repo (if it is already staged)

func (*Part_symbol) Commit 

func (part_symbol *Part_symbol) Commit(stage *StageStruct) *Part_symbol

commit part_symbol to the back repo (if it is already staged)

func (*Part_symbol) CommitVoid 

func (part_symbol *Part_symbol) CommitVoid(stage *StageStruct)

func (*Part_symbol) CopyBasicFields 

func (from *Part_symbol) CopyBasicFields(to *Part_symbol)

func (*Part_symbol) GetName 

func (part_symbol *Part_symbol) GetName() (res string)

for satisfaction of GongStruct interface

func (*Part_symbol) Stage 

func (part_symbol *Part_symbol) Stage(stage *StageStruct) *Part_symbol

Stage puts part_symbol to the model stage

func (*Part_symbol) Unstage 

func (part_symbol *Part_symbol) Unstage(stage *StageStruct) *Part_symbol

Unstage removes part_symbol off the model stage

func (*Part_symbol) UnstageVoid 

func (part_symbol *Part_symbol) UnstageVoid(stage *StageStruct)

UnstageVoid removes part_symbol off the model stage

type Part_symbol_WOP 

type Part_symbol_WOP struct {
	// insertion point
	Name string
}

type Part_transpose 

type Part_transpose struct {
	Name string
}

func CopyBranchPart_transpose 

func CopyBranchPart_transpose(mapOrigCopy map[any]any, part_transposeFrom *Part_transpose) (part_transposeTo *Part_transpose)

func (*Part_transpose) Checkout 

func (part_transpose *Part_transpose) Checkout(stage *StageStruct) *Part_transpose

Checkout part_transpose to the back repo (if it is already staged)

func (*Part_transpose) Commit 

func (part_transpose *Part_transpose) Commit(stage *StageStruct) *Part_transpose

commit part_transpose to the back repo (if it is already staged)

func (*Part_transpose) CommitVoid 

func (part_transpose *Part_transpose) CommitVoid(stage *StageStruct)

func (*Part_transpose) CopyBasicFields 

func (from *Part_transpose) CopyBasicFields(to *Part_transpose)

func (*Part_transpose) GetName 

func (part_transpose *Part_transpose) GetName() (res string)

for satisfaction of GongStruct interface

func (*Part_transpose) Stage 

func (part_transpose *Part_transpose) Stage(stage *StageStruct) *Part_transpose

Stage puts part_transpose to the model stage

func (*Part_transpose) Unstage 

func (part_transpose *Part_transpose) Unstage(stage *StageStruct) *Part_transpose

Unstage removes part_transpose off the model stage

func (*Part_transpose) UnstageVoid 

func (part_transpose *Part_transpose) UnstageVoid(stage *StageStruct)

UnstageVoid removes part_transpose off the model stage

type Part_transpose_WOP 

type Part_transpose_WOP struct {
	// insertion point
	Name string
}

type Pedal 

type Pedal struct {
	Name string
	Type *Pedal_type `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`

	Line *Yes_no `xml:"line,attr,omitempty" json:"line,omitempty"`

	Sign *Yes_no `xml:"sign,attr,omitempty" json:"sign,omitempty"`

	Abbreviated *Yes_no `xml:"abbreviated,attr,omitempty" json:"abbreviated,omitempty"`
}

func CopyBranchPedal 

func CopyBranchPedal(mapOrigCopy map[any]any, pedalFrom *Pedal) (pedalTo *Pedal)

func (*Pedal) Checkout 

func (pedal *Pedal) Checkout(stage *StageStruct) *Pedal

Checkout pedal to the back repo (if it is already staged)

func (*Pedal) Commit 

func (pedal *Pedal) Commit(stage *StageStruct) *Pedal

commit pedal to the back repo (if it is already staged)

func (*Pedal) CommitVoid 

func (pedal *Pedal) CommitVoid(stage *StageStruct)

func (*Pedal) CopyBasicFields 

func (from *Pedal) CopyBasicFields(to *Pedal)

func (*Pedal) GetName 

func (pedal *Pedal) GetName() (res string)

for satisfaction of GongStruct interface

func (*Pedal) Stage 

func (pedal *Pedal) Stage(stage *StageStruct) *Pedal

Stage puts pedal to the model stage

func (*Pedal) Unstage 

func (pedal *Pedal) Unstage(stage *StageStruct) *Pedal

Unstage removes pedal off the model stage

func (*Pedal) UnstageVoid 

func (pedal *Pedal) UnstageVoid(stage *StageStruct)

UnstageVoid removes pedal off the model stage

type Pedal_WOP 

type Pedal_WOP struct {
	// insertion point
	Name string
}

type Pedal_tuning 

type Pedal_tuning struct {
	Name string

	// The pedal-step element defines the pitch step for a single
	// harp pedal.
	Pedal_step *Step `xml:"pedal-step,omitempty" json:"pedal-step,omitempty"`

	// The pedal-alter element defines the chromatic alteration for a
	// single harp pedal.
	Pedal_alter *Semitones `xml:"pedal-alter,omitempty" json:"pedal-alter,omitempty"`
}

func CopyBranchPedal_tuning 

func CopyBranchPedal_tuning(mapOrigCopy map[any]any, pedal_tuningFrom *Pedal_tuning) (pedal_tuningTo *Pedal_tuning)

func (*Pedal_tuning) Checkout 

func (pedal_tuning *Pedal_tuning) Checkout(stage *StageStruct) *Pedal_tuning

Checkout pedal_tuning to the back repo (if it is already staged)

func (*Pedal_tuning) Commit 

func (pedal_tuning *Pedal_tuning) Commit(stage *StageStruct) *Pedal_tuning

commit pedal_tuning to the back repo (if it is already staged)

func (*Pedal_tuning) CommitVoid 

func (pedal_tuning *Pedal_tuning) CommitVoid(stage *StageStruct)

func (*Pedal_tuning) CopyBasicFields 

func (from *Pedal_tuning) CopyBasicFields(to *Pedal_tuning)

func (*Pedal_tuning) GetName 

func (pedal_tuning *Pedal_tuning) GetName() (res string)

for satisfaction of GongStruct interface

func (*Pedal_tuning) Stage 

func (pedal_tuning *Pedal_tuning) Stage(stage *StageStruct) *Pedal_tuning

Stage puts pedal_tuning to the model stage

func (*Pedal_tuning) Unstage 

func (pedal_tuning *Pedal_tuning) Unstage(stage *StageStruct) *Pedal_tuning

Unstage removes pedal_tuning off the model stage

func (*Pedal_tuning) UnstageVoid 

func (pedal_tuning *Pedal_tuning) UnstageVoid(stage *StageStruct)

UnstageVoid removes pedal_tuning off the model stage

type Pedal_tuning_WOP 

type Pedal_tuning_WOP struct {
	// insertion point
	Name string
}

type Pedal_type 

type Pedal_type string
const (
	Pedal_typeStart Pedal_type = "start"

	Pedal_typeStop Pedal_type = "stop"

	Pedal_typeSostenuto Pedal_type = "sostenuto"

	Pedal_typeChange Pedal_type = "change"

	Pedal_typeContinue_ Pedal_type = "continue"

	Pedal_typeDiscontinue Pedal_type = "discontinue"

	Pedal_typeResume Pedal_type = "resume"
)

func (Pedal_type) CodeValues 

func (pedal_type Pedal_type) CodeValues() (res []string)

func (Pedal_type) Codes 

func (pedal_type Pedal_type) Codes() (res []string)

func (*Pedal_type) FromCodeString 

func (pedal_type *Pedal_type) FromCodeString(input string) (err error)

func (*Pedal_type) FromString 

func (pedal_type *Pedal_type) FromString(input string) (err error)

func (*Pedal_type) ToCodeString 

func (pedal_type *Pedal_type) ToCodeString() (res string)

func (Pedal_type) ToString 

func (pedal_type Pedal_type) ToString() (res string)

Utility function for Pedal_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Per_minute 

type Per_minute string

func (Per_minute) CodeValues 

func (per_minute Per_minute) CodeValues() (res []string)

func (Per_minute) Codes 

func (per_minute Per_minute) Codes() (res []string)

func (*Per_minute) FromCodeString 

func (per_minute *Per_minute) FromCodeString(input string) (err error)

func (*Per_minute) FromString 

func (per_minute *Per_minute) FromString(input string) (err error)

func (*Per_minute) ToCodeString 

func (per_minute *Per_minute) ToCodeString() (res string)

func (Per_minute) ToString 

func (per_minute Per_minute) ToString() (res string)

Utility function for Per_minute if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Percent 

type Percent float64

type Percussion 

type Percussion struct {
	Name  string
	Glass *Glass `xml:"glass,omitempty" json:"glass,omitempty"`

	Metal *Metal `xml:"metal,omitempty" json:"metal,omitempty"`

	Wood *Wood `xml:"wood,omitempty" json:"wood,omitempty"`

	Pitched *Pitched `xml:"pitched,omitempty" json:"pitched,omitempty"`

	Membrane *Membrane `xml:"membrane,omitempty" json:"membrane,omitempty"`

	Effect *Effect `xml:"effect,omitempty" json:"effect,omitempty"`

	Timpani *Timpani `xml:"timpani,omitempty" json:"timpani,omitempty"`

	Beater *Beater `xml:"beater,omitempty" json:"beater,omitempty"`

	Stick *Stick `xml:"stick,omitempty" json:"stick,omitempty"`

	Stick_location *Stick_location `xml:"stick-location,omitempty" json:"stick-location,omitempty"`

	// The other-percussion element represents percussion pictograms
	// not defined elsewhere.
	Other_percussion *Other_text `xml:"other-percussion,omitempty" json:"other-percussion,omitempty"`
}

func CopyBranchPercussion 

func CopyBranchPercussion(mapOrigCopy map[any]any, percussionFrom *Percussion) (percussionTo *Percussion)

func (*Percussion) Checkout 

func (percussion *Percussion) Checkout(stage *StageStruct) *Percussion

Checkout percussion to the back repo (if it is already staged)

func (*Percussion) Commit 

func (percussion *Percussion) Commit(stage *StageStruct) *Percussion

commit percussion to the back repo (if it is already staged)

func (*Percussion) CommitVoid 

func (percussion *Percussion) CommitVoid(stage *StageStruct)

func (*Percussion) CopyBasicFields 

func (from *Percussion) CopyBasicFields(to *Percussion)

func (*Percussion) GetName 

func (percussion *Percussion) GetName() (res string)

for satisfaction of GongStruct interface

func (*Percussion) Stage 

func (percussion *Percussion) Stage(stage *StageStruct) *Percussion

Stage puts percussion to the model stage

func (*Percussion) Unstage 

func (percussion *Percussion) Unstage(stage *StageStruct) *Percussion

Unstage removes percussion off the model stage

func (*Percussion) UnstageVoid 

func (percussion *Percussion) UnstageVoid(stage *StageStruct)

UnstageVoid removes percussion off the model stage

type Percussion_WOP 

type Percussion_WOP struct {
	// insertion point
	Name string
}

type Pitch 

type Pitch struct {
	Name string
	Step *Step `xml:"step,omitempty" json:"step,omitempty"`

	Alter *Semitones `xml:"alter,omitempty" json:"alter,omitempty"`

	Octave *Octave `xml:"octave,omitempty" json:"octave,omitempty"`
}

func CopyBranchPitch 

func CopyBranchPitch(mapOrigCopy map[any]any, pitchFrom *Pitch) (pitchTo *Pitch)

func (*Pitch) Checkout 

func (pitch *Pitch) Checkout(stage *StageStruct) *Pitch

Checkout pitch to the back repo (if it is already staged)

func (*Pitch) Commit 

func (pitch *Pitch) Commit(stage *StageStruct) *Pitch

commit pitch to the back repo (if it is already staged)

func (*Pitch) CommitVoid 

func (pitch *Pitch) CommitVoid(stage *StageStruct)

func (*Pitch) CopyBasicFields 

func (from *Pitch) CopyBasicFields(to *Pitch)

func (*Pitch) GetName 

func (pitch *Pitch) GetName() (res string)

for satisfaction of GongStruct interface

func (*Pitch) Stage 

func (pitch *Pitch) Stage(stage *StageStruct) *Pitch

Stage puts pitch to the model stage

func (*Pitch) Unstage 

func (pitch *Pitch) Unstage(stage *StageStruct) *Pitch

Unstage removes pitch off the model stage

func (*Pitch) UnstageVoid 

func (pitch *Pitch) UnstageVoid(stage *StageStruct)

UnstageVoid removes pitch off the model stage

type Pitch_WOP 

type Pitch_WOP struct {
	// insertion point
	Name string
}

type Pitched 

type Pitched struct {
	Name  string
	Value *Pitched_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_pictogram_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchPitched 

func CopyBranchPitched(mapOrigCopy map[any]any, pitchedFrom *Pitched) (pitchedTo *Pitched)

func (*Pitched) Checkout 

func (pitched *Pitched) Checkout(stage *StageStruct) *Pitched

Checkout pitched to the back repo (if it is already staged)

func (*Pitched) Commit 

func (pitched *Pitched) Commit(stage *StageStruct) *Pitched

commit pitched to the back repo (if it is already staged)

func (*Pitched) CommitVoid 

func (pitched *Pitched) CommitVoid(stage *StageStruct)

func (*Pitched) CopyBasicFields 

func (from *Pitched) CopyBasicFields(to *Pitched)

func (*Pitched) GetName 

func (pitched *Pitched) GetName() (res string)

for satisfaction of GongStruct interface

func (*Pitched) Stage 

func (pitched *Pitched) Stage(stage *StageStruct) *Pitched

Stage puts pitched to the model stage

func (*Pitched) Unstage 

func (pitched *Pitched) Unstage(stage *StageStruct) *Pitched

Unstage removes pitched off the model stage

func (*Pitched) UnstageVoid 

func (pitched *Pitched) UnstageVoid(stage *StageStruct)

UnstageVoid removes pitched off the model stage

type Pitched_WOP 

type Pitched_WOP struct {
	// insertion point
	Name string
}

type Pitched_value 

type Pitched_value string
const (
	Pitched_valueCelesta Pitched_value = "celesta"

	Pitched_valueChimes Pitched_value = "chimes"

	Pitched_valueGlockenspiel Pitched_value = "glockenspiel"

	Pitched_valueLithophone Pitched_value = "lithophone"

	Pitched_valueMallet Pitched_value = "mallet"

	Pitched_valueMarimba Pitched_value = "marimba"

	Pitched_valueSteeldrums Pitched_value = "steel drums"

	Pitched_valueTubaphone Pitched_value = "tubaphone"

	Pitched_valueTubularchimes Pitched_value = "tubular chimes"

	Pitched_valueVibraphone Pitched_value = "vibraphone"

	Pitched_valueXylophone Pitched_value = "xylophone"
)

func (Pitched_value) CodeValues 

func (pitched_value Pitched_value) CodeValues() (res []string)

func (Pitched_value) Codes 

func (pitched_value Pitched_value) Codes() (res []string)

func (*Pitched_value) FromCodeString 

func (pitched_value *Pitched_value) FromCodeString(input string) (err error)

func (*Pitched_value) FromString 

func (pitched_value *Pitched_value) FromString(input string) (err error)

func (*Pitched_value) ToCodeString 

func (pitched_value *Pitched_value) ToCodeString() (res string)

func (Pitched_value) ToString 

func (pitched_value Pitched_value) ToString() (res string)

Utility function for Pitched_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Placement_text 

type Placement_text string

func (Placement_text) CodeValues 

func (placement_text Placement_text) CodeValues() (res []string)

func (Placement_text) Codes 

func (placement_text Placement_text) Codes() (res []string)

func (*Placement_text) FromCodeString 

func (placement_text *Placement_text) FromCodeString(input string) (err error)

func (*Placement_text) FromString 

func (placement_text *Placement_text) FromString(input string) (err error)

func (*Placement_text) ToCodeString 

func (placement_text *Placement_text) ToCodeString() (res string)

func (Placement_text) ToString 

func (placement_text Placement_text) ToString() (res string)

Utility function for Placement_text if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Play 

type Play struct {
	Name string

	// The ipa element represents International Phonetic Alphabet
	// (IPA) sounds for vocal music. String content is limited to IPA 2015
	// symbols represented in Unicode 13.0.
	Ipa string `xml:"ipa,omitempty" json:"ipa,omitempty"`

	Mute *Mute `xml:"mute,omitempty" json:"mute,omitempty"`

	Semi_pitched *Semi_pitched `xml:"semi-pitched,omitempty" json:"semi-pitched,omitempty"`

	Other_play *Other_play `xml:"other-play,omitempty" json:"other-play,omitempty"`

	Id *IDREF `xml:"id,attr,omitempty" json:"id,omitempty"`
}

func CopyBranchPlay 

func CopyBranchPlay(mapOrigCopy map[any]any, playFrom *Play) (playTo *Play)

func (*Play) Checkout 

func (play *Play) Checkout(stage *StageStruct) *Play

Checkout play to the back repo (if it is already staged)

func (*Play) Commit 

func (play *Play) Commit(stage *StageStruct) *Play

commit play to the back repo (if it is already staged)

func (*Play) CommitVoid 

func (play *Play) CommitVoid(stage *StageStruct)

func (*Play) CopyBasicFields 

func (from *Play) CopyBasicFields(to *Play)

func (*Play) GetName 

func (play *Play) GetName() (res string)

for satisfaction of GongStruct interface

func (*Play) Stage 

func (play *Play) Stage(stage *StageStruct) *Play

Stage puts play to the model stage

func (*Play) Unstage 

func (play *Play) Unstage(stage *StageStruct) *Play

Unstage removes play off the model stage

func (*Play) UnstageVoid 

func (play *Play) UnstageVoid(stage *StageStruct)

UnstageVoid removes play off the model stage

type Play_WOP 

type Play_WOP struct {
	// insertion point
	Name string
	Ipa  string
}

type Player 

type Player struct {
	Name string

	// The player-name element is typically used within a software
	// application, rather than appearing on the printed page of a score.
	Player_name string `xml:"player-name,omitempty" json:"player-name,omitempty"`

	Id *ID_MUSICXML `xml:"id,attr,omitempty" json:"id,omitempty"`
}

func CopyBranchPlayer 

func CopyBranchPlayer(mapOrigCopy map[any]any, playerFrom *Player) (playerTo *Player)

func (*Player) Checkout 

func (player *Player) Checkout(stage *StageStruct) *Player

Checkout player to the back repo (if it is already staged)

func (*Player) Commit 

func (player *Player) Commit(stage *StageStruct) *Player

commit player to the back repo (if it is already staged)

func (*Player) CommitVoid 

func (player *Player) CommitVoid(stage *StageStruct)

func (*Player) CopyBasicFields 

func (from *Player) CopyBasicFields(to *Player)

func (*Player) GetName 

func (player *Player) GetName() (res string)

for satisfaction of GongStruct interface

func (*Player) Stage 

func (player *Player) Stage(stage *StageStruct) *Player

Stage puts player to the model stage

func (*Player) Unstage 

func (player *Player) Unstage(stage *StageStruct) *Player

Unstage removes player off the model stage

func (*Player) UnstageVoid 

func (player *Player) UnstageVoid(stage *StageStruct)

UnstageVoid removes player off the model stage

type Player_WOP 

type Player_WOP struct {
	// insertion point
	Name        string
	Player_name string
}

type PointerToGongstruct 

type PointerToGongstruct interface {
	// insertion point for generic types
	GetName() string
	CommitVoid(*StageStruct)
	UnstageVoid(stage *StageStruct)
	comparable
}

Gongstruct is the type parameter for generated generic function that allows - access to staged instances - navigation between staged instances by going backward association links between gongstruct - full refactoring of Gongstruct identifiers / fields

type PointerToGongstructEnumIntField 

type PointerToGongstructEnumIntField interface {
	*PositiveInteger
	FromCodeString(input string) (err error)
}

type PointerToGongstructEnumStringField 

type PointerToGongstructEnumStringField interface {
	FromCodeString(input string) (err error)
}

type PositiveInteger 

type PositiveInteger int

func (PositiveInteger) CodeValues 

func (positiveinteger PositiveInteger) CodeValues() (res []int)

func (PositiveInteger) Codes 

func (positiveinteger PositiveInteger) Codes() (res []string)

func (*PositiveInteger) FromCodeString 

func (positiveinteger *PositiveInteger) FromCodeString(input string) (err error)

func (*PositiveInteger) FromInt 

func (positiveinteger *PositiveInteger) FromInt(input int) (err error)

func (*PositiveInteger) ToCodeString 

func (positiveinteger *PositiveInteger) ToCodeString() (res string)

func (PositiveInteger) ToInt 

func (positiveinteger PositiveInteger) ToInt() (res int)

Utility function for PositiveInteger if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Positive_decimal 

type Positive_decimal float64

type Positive_divisions 

type Positive_divisions Divisions

type Positive_integer_or_empty 

type Positive_integer_or_empty string

func (Positive_integer_or_empty) CodeValues 

func (positive_integer_or_empty Positive_integer_or_empty) CodeValues() (res []string)

func (Positive_integer_or_empty) Codes 

func (positive_integer_or_empty Positive_integer_or_empty) Codes() (res []string)

func (*Positive_integer_or_empty) FromCodeString 

func (positive_integer_or_empty *Positive_integer_or_empty) FromCodeString(input string) (err error)

func (*Positive_integer_or_empty) FromString 

func (positive_integer_or_empty *Positive_integer_or_empty) FromString(input string) (err error)

func (*Positive_integer_or_empty) ToCodeString 

func (positive_integer_or_empty *Positive_integer_or_empty) ToCodeString() (res string)

func (Positive_integer_or_empty) ToString 

func (positive_integer_or_empty Positive_integer_or_empty) ToString() (res string)

Utility function for Positive_integer_or_empty if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Principal_voice 

type Principal_voice struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Symbol *Principal_voice_symbol `xml:"symbol,attr,omitempty" json:"symbol,omitempty"`
}

func CopyBranchPrincipal_voice 

func CopyBranchPrincipal_voice(mapOrigCopy map[any]any, principal_voiceFrom *Principal_voice) (principal_voiceTo *Principal_voice)

func (*Principal_voice) Checkout 

func (principal_voice *Principal_voice) Checkout(stage *StageStruct) *Principal_voice

Checkout principal_voice to the back repo (if it is already staged)

func (*Principal_voice) Commit 

func (principal_voice *Principal_voice) Commit(stage *StageStruct) *Principal_voice

commit principal_voice to the back repo (if it is already staged)

func (*Principal_voice) CommitVoid 

func (principal_voice *Principal_voice) CommitVoid(stage *StageStruct)

func (*Principal_voice) CopyBasicFields 

func (from *Principal_voice) CopyBasicFields(to *Principal_voice)

func (*Principal_voice) GetName 

func (principal_voice *Principal_voice) GetName() (res string)

for satisfaction of GongStruct interface

func (*Principal_voice) Stage 

func (principal_voice *Principal_voice) Stage(stage *StageStruct) *Principal_voice

Stage puts principal_voice to the model stage

func (*Principal_voice) Unstage 

func (principal_voice *Principal_voice) Unstage(stage *StageStruct) *Principal_voice

Unstage removes principal_voice off the model stage

func (*Principal_voice) UnstageVoid 

func (principal_voice *Principal_voice) UnstageVoid(stage *StageStruct)

UnstageVoid removes principal_voice off the model stage

type Principal_voice_WOP 

type Principal_voice_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Principal_voice_symbol 

type Principal_voice_symbol string
const (
	Principal_voice_symbolHauptstimme Principal_voice_symbol = "Hauptstimme"

	Principal_voice_symbolNebenstimme Principal_voice_symbol = "Nebenstimme"

	Principal_voice_symbolPlain Principal_voice_symbol = "plain"

	Principal_voice_symbolNone Principal_voice_symbol = "none"
)

func (Principal_voice_symbol) CodeValues 

func (principal_voice_symbol Principal_voice_symbol) CodeValues() (res []string)

func (Principal_voice_symbol) Codes 

func (principal_voice_symbol Principal_voice_symbol) Codes() (res []string)

func (*Principal_voice_symbol) FromCodeString 

func (principal_voice_symbol *Principal_voice_symbol) FromCodeString(input string) (err error)

func (*Principal_voice_symbol) FromString 

func (principal_voice_symbol *Principal_voice_symbol) FromString(input string) (err error)

func (*Principal_voice_symbol) ToCodeString 

func (principal_voice_symbol *Principal_voice_symbol) ToCodeString() (res string)

func (Principal_voice_symbol) ToString 

func (principal_voice_symbol Principal_voice_symbol) ToString() (res string)

Utility function for Principal_voice_symbol if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Print 

type Print struct {
	Name           string
	Measure_layout *Measure_layout `xml:"measure-layout,omitempty" json:"measure-layout,omitempty"`

	Measure_numbering *Measure_numbering `xml:"measure-numbering,omitempty" json:"measure-numbering,omitempty"`

	Part_name_display *Name_display `xml:"part-name-display,omitempty" json:"part-name-display,omitempty"`

	Part_abbreviation_display *Name_display `xml:"part-abbreviation-display,omitempty" json:"part-abbreviation-display,omitempty"`
}

func CopyBranchPrint 

func CopyBranchPrint(mapOrigCopy map[any]any, printFrom *Print) (printTo *Print)

func (*Print) Checkout 

func (print *Print) Checkout(stage *StageStruct) *Print

Checkout print to the back repo (if it is already staged)

func (*Print) Commit 

func (print *Print) Commit(stage *StageStruct) *Print

commit print to the back repo (if it is already staged)

func (*Print) CommitVoid 

func (print *Print) CommitVoid(stage *StageStruct)

func (*Print) CopyBasicFields 

func (from *Print) CopyBasicFields(to *Print)

func (*Print) GetName 

func (print *Print) GetName() (res string)

for satisfaction of GongStruct interface

func (*Print) Stage 

func (print *Print) Stage(stage *StageStruct) *Print

Stage puts print to the model stage

func (*Print) Unstage 

func (print *Print) Unstage(stage *StageStruct) *Print

Unstage removes print off the model stage

func (*Print) UnstageVoid 

func (print *Print) UnstageVoid(stage *StageStruct)

UnstageVoid removes print off the model stage 

type Print_WOP struct {
	// insertion point
	Name string
}

type Release 

type Release struct {
	Name string
	*Empty

	Offset *Divisions `xml:"offset,attr,omitempty" json:"offset,omitempty"`
}

func CopyBranchRelease 

func CopyBranchRelease(mapOrigCopy map[any]any, releaseFrom *Release) (releaseTo *Release)

func (*Release) Checkout 

func (release *Release) Checkout(stage *StageStruct) *Release

Checkout release to the back repo (if it is already staged)

func (*Release) Commit 

func (release *Release) Commit(stage *StageStruct) *Release

commit release to the back repo (if it is already staged)

func (*Release) CommitVoid 

func (release *Release) CommitVoid(stage *StageStruct)

func (*Release) CopyBasicFields 

func (from *Release) CopyBasicFields(to *Release)

func (*Release) GetName 

func (release *Release) GetName() (res string)

for satisfaction of GongStruct interface

func (*Release) Stage 

func (release *Release) Stage(stage *StageStruct) *Release

Stage puts release to the model stage

func (*Release) Unstage 

func (release *Release) Unstage(stage *StageStruct) *Release

Unstage removes release off the model stage

func (*Release) UnstageVoid 

func (release *Release) UnstageVoid(stage *StageStruct)

UnstageVoid removes release off the model stage

type Release_WOP 

type Release_WOP struct {
	// insertion point
	Name string
}

type Repeat 

type Repeat struct {
	Name      string
	Direction *Backward_forward `xml:"direction,attr,omitempty" json:"direction,omitempty"`

	Times uint32 `xml:"times,attr,omitempty" json:"times,omitempty"`

	After_jump *Yes_no `xml:"after-jump,attr,omitempty" json:"after-jump,omitempty"`

	Winged *Winged `xml:"winged,attr,omitempty" json:"winged,omitempty"`
}

func CopyBranchRepeat 

func CopyBranchRepeat(mapOrigCopy map[any]any, repeatFrom *Repeat) (repeatTo *Repeat)

func (*Repeat) Checkout 

func (repeat *Repeat) Checkout(stage *StageStruct) *Repeat

Checkout repeat to the back repo (if it is already staged)

func (*Repeat) Commit 

func (repeat *Repeat) Commit(stage *StageStruct) *Repeat

commit repeat to the back repo (if it is already staged)

func (*Repeat) CommitVoid 

func (repeat *Repeat) CommitVoid(stage *StageStruct)

func (*Repeat) CopyBasicFields 

func (from *Repeat) CopyBasicFields(to *Repeat)

func (*Repeat) GetName 

func (repeat *Repeat) GetName() (res string)

for satisfaction of GongStruct interface

func (*Repeat) Stage 

func (repeat *Repeat) Stage(stage *StageStruct) *Repeat

Stage puts repeat to the model stage

func (*Repeat) Unstage 

func (repeat *Repeat) Unstage(stage *StageStruct) *Repeat

Unstage removes repeat off the model stage

func (*Repeat) UnstageVoid 

func (repeat *Repeat) UnstageVoid(stage *StageStruct)

UnstageVoid removes repeat off the model stage

type Repeat_WOP 

type Repeat_WOP struct {
	// insertion point
	Name string
}

type Rest 

type Rest struct {
	Name    string
	Measure *Yes_no `xml:"measure,attr,omitempty" json:"measure,omitempty"`
}

func CopyBranchRest 

func CopyBranchRest(mapOrigCopy map[any]any, restFrom *Rest) (restTo *Rest)

func (*Rest) Checkout 

func (rest *Rest) Checkout(stage *StageStruct) *Rest

Checkout rest to the back repo (if it is already staged)

func (*Rest) Commit 

func (rest *Rest) Commit(stage *StageStruct) *Rest

commit rest to the back repo (if it is already staged)

func (*Rest) CommitVoid 

func (rest *Rest) CommitVoid(stage *StageStruct)

func (*Rest) CopyBasicFields 

func (from *Rest) CopyBasicFields(to *Rest)

func (*Rest) GetName 

func (rest *Rest) GetName() (res string)

for satisfaction of GongStruct interface

func (*Rest) Stage 

func (rest *Rest) Stage(stage *StageStruct) *Rest

Stage puts rest to the model stage

func (*Rest) Unstage 

func (rest *Rest) Unstage(stage *StageStruct) *Rest

Unstage removes rest off the model stage

func (*Rest) UnstageVoid 

func (rest *Rest) UnstageVoid(stage *StageStruct)

UnstageVoid removes rest off the model stage

type Rest_WOP 

type Rest_WOP struct {
	// insertion point
	Name string
}

type ReverseField 

type ReverseField struct {
	GongstructName string
	Fieldname      string
}

func GetReverseFields 

func GetReverseFields[Type Gongstruct]() (res []ReverseField)

type Right_left_middle 

type Right_left_middle string
const (
	Right_left_middleRight Right_left_middle = "right"

	Right_left_middleLeft Right_left_middle = "left"

	Right_left_middleMiddle Right_left_middle = "middle"
)

func (Right_left_middle) CodeValues 

func (right_left_middle Right_left_middle) CodeValues() (res []string)

func (Right_left_middle) Codes 

func (right_left_middle Right_left_middle) Codes() (res []string)

func (*Right_left_middle) FromCodeString 

func (right_left_middle *Right_left_middle) FromCodeString(input string) (err error)

func (*Right_left_middle) FromString 

func (right_left_middle *Right_left_middle) FromString(input string) (err error)

func (*Right_left_middle) ToCodeString 

func (right_left_middle *Right_left_middle) ToCodeString() (res string)

func (Right_left_middle) ToString 

func (right_left_middle Right_left_middle) ToString() (res string)

Utility function for Right_left_middle if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Root 

type Root struct {
	Name      string
	Root_step *Root_step `xml:"root-step,omitempty" json:"root-step,omitempty"`

	// The root-alter element 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.
	Root_alter *Harmony_alter `xml:"root-alter,omitempty" json:"root-alter,omitempty"`
}

func CopyBranchRoot 

func CopyBranchRoot(mapOrigCopy map[any]any, rootFrom *Root) (rootTo *Root)

func (*Root) Checkout 

func (root *Root) Checkout(stage *StageStruct) *Root

Checkout root to the back repo (if it is already staged)

func (*Root) Commit 

func (root *Root) Commit(stage *StageStruct) *Root

commit root to the back repo (if it is already staged)

func (*Root) CommitVoid 

func (root *Root) CommitVoid(stage *StageStruct)

func (*Root) CopyBasicFields 

func (from *Root) CopyBasicFields(to *Root)

func (*Root) GetName 

func (root *Root) GetName() (res string)

for satisfaction of GongStruct interface

func (*Root) Stage 

func (root *Root) Stage(stage *StageStruct) *Root

Stage puts root to the model stage

func (*Root) Unstage 

func (root *Root) Unstage(stage *StageStruct) *Root

Unstage removes root off the model stage

func (*Root) UnstageVoid 

func (root *Root) UnstageVoid(stage *StageStruct)

UnstageVoid removes root off the model stage

type Root_WOP 

type Root_WOP struct {
	// insertion point
	Name string
}

type Root_step 

type Root_step struct {
	Name  string
	Value *Step `xml:",chardata" json:"-,"`

	Text string `xml:"text,attr,omitempty" json:"text,omitempty"`
}

func CopyBranchRoot_step 

func CopyBranchRoot_step(mapOrigCopy map[any]any, root_stepFrom *Root_step) (root_stepTo *Root_step)

func (*Root_step) Checkout 

func (root_step *Root_step) Checkout(stage *StageStruct) *Root_step

Checkout root_step to the back repo (if it is already staged)

func (*Root_step) Commit 

func (root_step *Root_step) Commit(stage *StageStruct) *Root_step

commit root_step to the back repo (if it is already staged)

func (*Root_step) CommitVoid 

func (root_step *Root_step) CommitVoid(stage *StageStruct)

func (*Root_step) CopyBasicFields 

func (from *Root_step) CopyBasicFields(to *Root_step)

func (*Root_step) GetName 

func (root_step *Root_step) GetName() (res string)

for satisfaction of GongStruct interface

func (*Root_step) Stage 

func (root_step *Root_step) Stage(stage *StageStruct) *Root_step

Stage puts root_step to the model stage

func (*Root_step) Unstage 

func (root_step *Root_step) Unstage(stage *StageStruct) *Root_step

Unstage removes root_step off the model stage

func (*Root_step) UnstageVoid 

func (root_step *Root_step) UnstageVoid(stage *StageStruct)

UnstageVoid removes root_step off the model stage

type Root_step_WOP 

type Root_step_WOP struct {
	// insertion point
	Name string
	Text string
}

type Rotation_degrees 

type Rotation_degrees float64

type SOAPBodyRequest 

type SOAPBodyRequest struct {
	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Body"`
}

type SOAPBodyResponse 

type SOAPBodyResponse struct {
	XMLName xml.Name `xml:"soap:Body"`
	Fault   *Fault   `xml:",omitempty"`
}

type SOAPEnvelopeRequest 

type SOAPEnvelopeRequest struct {
	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`
	Body    SOAPBodyRequest
}

type SOAPEnvelopeResponse 

type SOAPEnvelopeResponse struct {
	XMLName    xml.Name `xml:"soap:Envelope"`
	PrefixSoap string   `xml:"xmlns:soap,attr"`
	PrefixXsi  string   `xml:"xmlns:xsi,attr"`
	PrefixXsd  string   `xml:"xmlns:xsd,attr"`

	Body SOAPBodyResponse
}

func NewSOAPEnvelopResponse 

func NewSOAPEnvelopResponse() *SOAPEnvelopeResponse

type Scaling 

type Scaling struct {
	Name        string
	Millimeters *Millimeters `xml:"millimeters,omitempty" json:"millimeters,omitempty"`

	Tenths *Tenths `xml:"tenths,omitempty" json:"tenths,omitempty"`
}

func CopyBranchScaling 

func CopyBranchScaling(mapOrigCopy map[any]any, scalingFrom *Scaling) (scalingTo *Scaling)

func (*Scaling) Checkout 

func (scaling *Scaling) Checkout(stage *StageStruct) *Scaling

Checkout scaling to the back repo (if it is already staged)

func (*Scaling) Commit 

func (scaling *Scaling) Commit(stage *StageStruct) *Scaling

commit scaling to the back repo (if it is already staged)

func (*Scaling) CommitVoid 

func (scaling *Scaling) CommitVoid(stage *StageStruct)

func (*Scaling) CopyBasicFields 

func (from *Scaling) CopyBasicFields(to *Scaling)

func (*Scaling) GetName 

func (scaling *Scaling) GetName() (res string)

for satisfaction of GongStruct interface

func (*Scaling) Stage 

func (scaling *Scaling) Stage(stage *StageStruct) *Scaling

Stage puts scaling to the model stage

func (*Scaling) Unstage 

func (scaling *Scaling) Unstage(stage *StageStruct) *Scaling

Unstage removes scaling off the model stage

func (*Scaling) UnstageVoid 

func (scaling *Scaling) UnstageVoid(stage *StageStruct)

UnstageVoid removes scaling off the model stage

type Scaling_WOP 

type Scaling_WOP struct {
	// insertion point
	Name string
}

type Scordatura 

type Scordatura struct {
	Name   string
	Accord []*Accord `xml:"accord,omitempty" json:"accord,omitempty"`
}

func CopyBranchScordatura 

func CopyBranchScordatura(mapOrigCopy map[any]any, scordaturaFrom *Scordatura) (scordaturaTo *Scordatura)

func (*Scordatura) Checkout 

func (scordatura *Scordatura) Checkout(stage *StageStruct) *Scordatura

Checkout scordatura to the back repo (if it is already staged)

func (*Scordatura) Commit 

func (scordatura *Scordatura) Commit(stage *StageStruct) *Scordatura

commit scordatura to the back repo (if it is already staged)

func (*Scordatura) CommitVoid 

func (scordatura *Scordatura) CommitVoid(stage *StageStruct)

func (*Scordatura) CopyBasicFields 

func (from *Scordatura) CopyBasicFields(to *Scordatura)

func (*Scordatura) GetName 

func (scordatura *Scordatura) GetName() (res string)

for satisfaction of GongStruct interface

func (*Scordatura) Stage 

func (scordatura *Scordatura) Stage(stage *StageStruct) *Scordatura

Stage puts scordatura to the model stage

func (*Scordatura) Unstage 

func (scordatura *Scordatura) Unstage(stage *StageStruct) *Scordatura

Unstage removes scordatura off the model stage

func (*Scordatura) UnstageVoid 

func (scordatura *Scordatura) UnstageVoid(stage *StageStruct)

UnstageVoid removes scordatura off the model stage

type Scordatura_WOP 

type Scordatura_WOP struct {
	// insertion point
	Name string
}

type Score_instrument 

type Score_instrument struct {
	Name string

	// The instrument-name element is typically used within a
	// software application, rather than appearing on the printed page of a score.
	Instrument_name string `xml:"instrument-name,omitempty" json:"instrument-name,omitempty"`

	// The optional instrument-abbreviation element is typically used
	// within a software application, rather than appearing on the printed page of
	// a score.
	Instrument_abbreviation string `xml:"instrument-abbreviation,omitempty" json:"instrument-abbreviation,omitempty"`

	Id *ID_MUSICXML `xml:"id,attr,omitempty" json:"id,omitempty"`
}

func CopyBranchScore_instrument 

func CopyBranchScore_instrument(mapOrigCopy map[any]any, score_instrumentFrom *Score_instrument) (score_instrumentTo *Score_instrument)

func (*Score_instrument) Checkout 

func (score_instrument *Score_instrument) Checkout(stage *StageStruct) *Score_instrument

Checkout score_instrument to the back repo (if it is already staged)

func (*Score_instrument) Commit 

func (score_instrument *Score_instrument) Commit(stage *StageStruct) *Score_instrument

commit score_instrument to the back repo (if it is already staged)

func (*Score_instrument) CommitVoid 

func (score_instrument *Score_instrument) CommitVoid(stage *StageStruct)

func (*Score_instrument) CopyBasicFields 

func (from *Score_instrument) CopyBasicFields(to *Score_instrument)

func (*Score_instrument) GetName 

func (score_instrument *Score_instrument) GetName() (res string)

for satisfaction of GongStruct interface

func (*Score_instrument) Stage 

func (score_instrument *Score_instrument) Stage(stage *StageStruct) *Score_instrument

Stage puts score_instrument to the model stage

func (*Score_instrument) Unstage 

func (score_instrument *Score_instrument) Unstage(stage *StageStruct) *Score_instrument

Unstage removes score_instrument off the model stage

func (*Score_instrument) UnstageVoid 

func (score_instrument *Score_instrument) UnstageVoid(stage *StageStruct)

UnstageVoid removes score_instrument off the model stage

type Score_instrument_WOP 

type Score_instrument_WOP struct {
	// insertion point
	Name                    string
	Instrument_name         string
	Instrument_abbreviation string
}

type Score_part 

type Score_part struct {
	Name           string
	Identification *Identification `xml:"identification,omitempty" json:"identification,omitempty"`

	Part_link []*Part_link `xml:"part-link,omitempty" json:"part-link,omitempty"`

	Part_name *Part_name `xml:"part-name,omitempty" json:"part-name,omitempty"`

	Part_name_display *Name_display `xml:"part-name-display,omitempty" json:"part-name-display,omitempty"`

	Part_abbreviation *Part_name `xml:"part-abbreviation,omitempty" json:"part-abbreviation,omitempty"`

	Part_abbreviation_display *Name_display `xml:"part-abbreviation-display,omitempty" json:"part-abbreviation-display,omitempty"`

	// The group element allows the use of different versions of the
	// part for different purposes. Typical values include score, parts, sound, and
	// data. Ordering information can be derived from the ordering within a
	// MusicXML score or opus.
	Group []string `xml:"group,omitempty" json:"group,omitempty"`

	Score_instrument []*Score_instrument `xml:"score-instrument,omitempty" json:"score-instrument,omitempty"`

	Player []*Player `xml:"player,omitempty" json:"player,omitempty"`

	Id *ID_MUSICXML `xml:"id,attr,omitempty" json:"id,omitempty"`
}

func CopyBranchScore_part 

func CopyBranchScore_part(mapOrigCopy map[any]any, score_partFrom *Score_part) (score_partTo *Score_part)

func (*Score_part) Checkout 

func (score_part *Score_part) Checkout(stage *StageStruct) *Score_part

Checkout score_part to the back repo (if it is already staged)

func (*Score_part) Commit 

func (score_part *Score_part) Commit(stage *StageStruct) *Score_part

commit score_part to the back repo (if it is already staged)

func (*Score_part) CommitVoid 

func (score_part *Score_part) CommitVoid(stage *StageStruct)

func (*Score_part) CopyBasicFields 

func (from *Score_part) CopyBasicFields(to *Score_part)

func (*Score_part) GetName 

func (score_part *Score_part) GetName() (res string)

for satisfaction of GongStruct interface

func (*Score_part) Stage 

func (score_part *Score_part) Stage(stage *StageStruct) *Score_part

Stage puts score_part to the model stage

func (*Score_part) Unstage 

func (score_part *Score_part) Unstage(stage *StageStruct) *Score_part

Unstage removes score_part off the model stage

func (*Score_part) UnstageVoid 

func (score_part *Score_part) UnstageVoid(stage *StageStruct)

UnstageVoid removes score_part off the model stage

type Score_part_WOP 

type Score_part_WOP struct {
	// insertion point
	Name string
}

type Score_partwise 

type Score_partwise struct {
	Name    string
	XMLName xml.Name `xml:" score-partwise"`

	Part []struct {
		Measure []struct {
		} `xml:"measure,omitempty" json:"measure,omitempty"`
	} `xml:"part,omitempty" json:"part,omitempty"`
}

func CopyBranchScore_partwise 

func CopyBranchScore_partwise(mapOrigCopy map[any]any, score_partwiseFrom *Score_partwise) (score_partwiseTo *Score_partwise)

func (*Score_partwise) Checkout 

func (score_partwise *Score_partwise) Checkout(stage *StageStruct) *Score_partwise

Checkout score_partwise to the back repo (if it is already staged)

func (*Score_partwise) Commit 

func (score_partwise *Score_partwise) Commit(stage *StageStruct) *Score_partwise

commit score_partwise to the back repo (if it is already staged)

func (*Score_partwise) CommitVoid 

func (score_partwise *Score_partwise) CommitVoid(stage *StageStruct)

func (*Score_partwise) CopyBasicFields 

func (from *Score_partwise) CopyBasicFields(to *Score_partwise)

func (*Score_partwise) GetName 

func (score_partwise *Score_partwise) GetName() (res string)

for satisfaction of GongStruct interface

func (*Score_partwise) Stage 

func (score_partwise *Score_partwise) Stage(stage *StageStruct) *Score_partwise

Stage puts score_partwise to the model stage

func (*Score_partwise) Unstage 

func (score_partwise *Score_partwise) Unstage(stage *StageStruct) *Score_partwise

Unstage removes score_partwise off the model stage

func (*Score_partwise) UnstageVoid 

func (score_partwise *Score_partwise) UnstageVoid(stage *StageStruct)

UnstageVoid removes score_partwise off the model stage

type Score_partwise_WOP 

type Score_partwise_WOP struct {
	// insertion point
	Name string
}

type Score_timewise 

type Score_timewise struct {
	Name    string
	XMLName xml.Name `xml:" score-timewise"`

	Measure []struct {
		Part []struct {
		} `xml:"part,omitempty" json:"part,omitempty"`
	} `xml:"measure,omitempty" json:"measure,omitempty"`
}

func CopyBranchScore_timewise 

func CopyBranchScore_timewise(mapOrigCopy map[any]any, score_timewiseFrom *Score_timewise) (score_timewiseTo *Score_timewise)

func (*Score_timewise) Checkout 

func (score_timewise *Score_timewise) Checkout(stage *StageStruct) *Score_timewise

Checkout score_timewise to the back repo (if it is already staged)

func (*Score_timewise) Commit 

func (score_timewise *Score_timewise) Commit(stage *StageStruct) *Score_timewise

commit score_timewise to the back repo (if it is already staged)

func (*Score_timewise) CommitVoid 

func (score_timewise *Score_timewise) CommitVoid(stage *StageStruct)

func (*Score_timewise) CopyBasicFields 

func (from *Score_timewise) CopyBasicFields(to *Score_timewise)

func (*Score_timewise) GetName 

func (score_timewise *Score_timewise) GetName() (res string)

for satisfaction of GongStruct interface

func (*Score_timewise) Stage 

func (score_timewise *Score_timewise) Stage(stage *StageStruct) *Score_timewise

Stage puts score_timewise to the model stage

func (*Score_timewise) Unstage 

func (score_timewise *Score_timewise) Unstage(stage *StageStruct) *Score_timewise

Unstage removes score_timewise off the model stage

func (*Score_timewise) UnstageVoid 

func (score_timewise *Score_timewise) UnstageVoid(stage *StageStruct)

UnstageVoid removes score_timewise off the model stage

type Score_timewise_WOP 

type Score_timewise_WOP struct {
	// insertion point
	Name string
}

type Segno 

type Segno struct {
	Name  string
	Smufl *Smufl_segno_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchSegno 

func CopyBranchSegno(mapOrigCopy map[any]any, segnoFrom *Segno) (segnoTo *Segno)

func (*Segno) Checkout 

func (segno *Segno) Checkout(stage *StageStruct) *Segno

Checkout segno to the back repo (if it is already staged)

func (*Segno) Commit 

func (segno *Segno) Commit(stage *StageStruct) *Segno

commit segno to the back repo (if it is already staged)

func (*Segno) CommitVoid 

func (segno *Segno) CommitVoid(stage *StageStruct)

func (*Segno) CopyBasicFields 

func (from *Segno) CopyBasicFields(to *Segno)

func (*Segno) GetName 

func (segno *Segno) GetName() (res string)

for satisfaction of GongStruct interface

func (*Segno) Stage 

func (segno *Segno) Stage(stage *StageStruct) *Segno

Stage puts segno to the model stage

func (*Segno) Unstage 

func (segno *Segno) Unstage(stage *StageStruct) *Segno

Unstage removes segno off the model stage

func (*Segno) UnstageVoid 

func (segno *Segno) UnstageVoid(stage *StageStruct)

UnstageVoid removes segno off the model stage

type Segno_WOP 

type Segno_WOP struct {
	// insertion point
	Name string
}

type Semi_pitched 

type Semi_pitched string
const (
	Semi_pitchedHigh Semi_pitched = "high"

	Semi_pitchedMedium_high Semi_pitched = "medium-high"

	Semi_pitchedMedium Semi_pitched = "medium"

	Semi_pitchedMedium_low Semi_pitched = "medium-low"

	Semi_pitchedLow Semi_pitched = "low"

	Semi_pitchedVery_low Semi_pitched = "very-low"
)

func (Semi_pitched) CodeValues 

func (semi_pitched Semi_pitched) CodeValues() (res []string)

func (Semi_pitched) Codes 

func (semi_pitched Semi_pitched) Codes() (res []string)

func (*Semi_pitched) FromCodeString 

func (semi_pitched *Semi_pitched) FromCodeString(input string) (err error)

func (*Semi_pitched) FromString 

func (semi_pitched *Semi_pitched) FromString(input string) (err error)

func (*Semi_pitched) ToCodeString 

func (semi_pitched *Semi_pitched) ToCodeString() (res string)

func (Semi_pitched) ToString 

func (semi_pitched Semi_pitched) ToString() (res string)

Utility function for Semi_pitched if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Semitones 

type Semitones float64

type Show_frets 

type Show_frets string
const (
	Show_fretsNumbers Show_frets = "numbers"

	Show_fretsLetters Show_frets = "letters"
)

func (Show_frets) CodeValues 

func (show_frets Show_frets) CodeValues() (res []string)

func (Show_frets) Codes 

func (show_frets Show_frets) Codes() (res []string)

func (*Show_frets) FromCodeString 

func (show_frets *Show_frets) FromCodeString(input string) (err error)

func (*Show_frets) FromString 

func (show_frets *Show_frets) FromString(input string) (err error)

func (*Show_frets) ToCodeString 

func (show_frets *Show_frets) ToCodeString() (res string)

func (Show_frets) ToString 

func (show_frets Show_frets) ToString() (res string)

Utility function for Show_frets if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Show_tuplet 

type Show_tuplet string
const (
	Show_tupletActual Show_tuplet = "actual"

	Show_tupletBoth Show_tuplet = "both"

	Show_tupletNone Show_tuplet = "none"
)

func (Show_tuplet) CodeValues 

func (show_tuplet Show_tuplet) CodeValues() (res []string)

func (Show_tuplet) Codes 

func (show_tuplet Show_tuplet) Codes() (res []string)

func (*Show_tuplet) FromCodeString 

func (show_tuplet *Show_tuplet) FromCodeString(input string) (err error)

func (*Show_tuplet) FromString 

func (show_tuplet *Show_tuplet) FromString(input string) (err error)

func (*Show_tuplet) ToCodeString 

func (show_tuplet *Show_tuplet) ToCodeString() (res string)

func (Show_tuplet) ToString 

func (show_tuplet Show_tuplet) ToString() (res string)

Utility function for Show_tuplet if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Slash 

type Slash struct {
	Name string
	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Use_dots *Yes_no `xml:"use-dots,attr,omitempty" json:"use-dots,omitempty"`

	Use_stems *Yes_no `xml:"use-stems,attr,omitempty" json:"use-stems,omitempty"`
}

func CopyBranchSlash 

func CopyBranchSlash(mapOrigCopy map[any]any, slashFrom *Slash) (slashTo *Slash)

func (*Slash) Checkout 

func (slash *Slash) Checkout(stage *StageStruct) *Slash

Checkout slash to the back repo (if it is already staged)

func (*Slash) Commit 

func (slash *Slash) Commit(stage *StageStruct) *Slash

commit slash to the back repo (if it is already staged)

func (*Slash) CommitVoid 

func (slash *Slash) CommitVoid(stage *StageStruct)

func (*Slash) CopyBasicFields 

func (from *Slash) CopyBasicFields(to *Slash)

func (*Slash) GetName 

func (slash *Slash) GetName() (res string)

for satisfaction of GongStruct interface

func (*Slash) Stage 

func (slash *Slash) Stage(stage *StageStruct) *Slash

Stage puts slash to the model stage

func (*Slash) Unstage 

func (slash *Slash) Unstage(stage *StageStruct) *Slash

Unstage removes slash off the model stage

func (*Slash) UnstageVoid 

func (slash *Slash) UnstageVoid(stage *StageStruct)

UnstageVoid removes slash off the model stage

type Slash_WOP 

type Slash_WOP struct {
	// insertion point
	Name string
}

type Slide 

type Slide struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchSlide 

func CopyBranchSlide(mapOrigCopy map[any]any, slideFrom *Slide) (slideTo *Slide)

func (*Slide) Checkout 

func (slide *Slide) Checkout(stage *StageStruct) *Slide

Checkout slide to the back repo (if it is already staged)

func (*Slide) Commit 

func (slide *Slide) Commit(stage *StageStruct) *Slide

commit slide to the back repo (if it is already staged)

func (*Slide) CommitVoid 

func (slide *Slide) CommitVoid(stage *StageStruct)

func (*Slide) CopyBasicFields 

func (from *Slide) CopyBasicFields(to *Slide)

func (*Slide) GetName 

func (slide *Slide) GetName() (res string)

for satisfaction of GongStruct interface

func (*Slide) Stage 

func (slide *Slide) Stage(stage *StageStruct) *Slide

Stage puts slide to the model stage

func (*Slide) Unstage 

func (slide *Slide) Unstage(stage *StageStruct) *Slide

Unstage removes slide off the model stage

func (*Slide) UnstageVoid 

func (slide *Slide) UnstageVoid(stage *StageStruct)

UnstageVoid removes slide off the model stage

type Slide_WOP 

type Slide_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Slur 

type Slur struct {
	Name string
	Type *Start_stop_continue `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchSlur 

func CopyBranchSlur(mapOrigCopy map[any]any, slurFrom *Slur) (slurTo *Slur)

func (*Slur) Checkout 

func (slur *Slur) Checkout(stage *StageStruct) *Slur

Checkout slur to the back repo (if it is already staged)

func (*Slur) Commit 

func (slur *Slur) Commit(stage *StageStruct) *Slur

commit slur to the back repo (if it is already staged)

func (*Slur) CommitVoid 

func (slur *Slur) CommitVoid(stage *StageStruct)

func (*Slur) CopyBasicFields 

func (from *Slur) CopyBasicFields(to *Slur)

func (*Slur) GetName 

func (slur *Slur) GetName() (res string)

for satisfaction of GongStruct interface

func (*Slur) Stage 

func (slur *Slur) Stage(stage *StageStruct) *Slur

Stage puts slur to the model stage

func (*Slur) Unstage 

func (slur *Slur) Unstage(stage *StageStruct) *Slur

Unstage removes slur off the model stage

func (*Slur) UnstageVoid 

func (slur *Slur) UnstageVoid(stage *StageStruct)

UnstageVoid removes slur off the model stage

type Slur_WOP 

type Slur_WOP struct {
	// insertion point
	Name string
}

type Smufl_accidental_glyph_name 

type Smufl_accidental_glyph_name Smufl_glyph_name

type Smufl_coda_glyph_name 

type Smufl_coda_glyph_name Smufl_glyph_name

type Smufl_glyph_name 

type Smufl_glyph_name NMTOKEN

type Smufl_lyrics_glyph_name 

type Smufl_lyrics_glyph_name Smufl_glyph_name

type Smufl_pictogram_glyph_name 

type Smufl_pictogram_glyph_name Smufl_glyph_name

type Smufl_segno_glyph_name 

type Smufl_segno_glyph_name Smufl_glyph_name

type Smufl_wavy_line_glyph_name 

type Smufl_wavy_line_glyph_name Smufl_glyph_name

type Sound 

type Sound struct {
	Name  string
	Swing *Swing `xml:"swing,omitempty" json:"swing,omitempty"`

	Offset *Offset `xml:"offset,omitempty" json:"offset,omitempty"`

	Tempo *Non_negative_decimal `xml:"tempo,attr,omitempty" json:"tempo,omitempty"`

	Dynamics *Non_negative_decimal `xml:"dynamics,attr,omitempty" json:"dynamics,omitempty"`

	Dacapo *Yes_no `xml:"dacapo,attr,omitempty" json:"dacapo,omitempty"`

	Segno string `xml:"segno,attr,omitempty" json:"segno,omitempty"`

	Dalsegno string `xml:"dalsegno,attr,omitempty" json:"dalsegno,omitempty"`

	Coda string `xml:"coda,attr,omitempty" json:"coda,omitempty"`

	Tocoda string `xml:"tocoda,attr,omitempty" json:"tocoda,omitempty"`

	Divisions *Divisions `xml:"divisions,attr,omitempty" json:"divisions,omitempty"`

	Forward_repeat *Yes_no `xml:"forward-repeat,attr,omitempty" json:"forward-repeat,omitempty"`

	Fine string `xml:"fine,attr,omitempty" json:"fine,omitempty"`

	Time_only *Time_only `xml:"time-only,attr,omitempty" json:"time-only,omitempty"`

	Pizzicato *Yes_no `xml:"pizzicato,attr,omitempty" json:"pizzicato,omitempty"`

	Pan *Rotation_degrees `xml:"pan,attr,omitempty" json:"pan,omitempty"`

	Elevation *Rotation_degrees `xml:"elevation,attr,omitempty" json:"elevation,omitempty"`

	Damper_pedal *Yes_no_number `xml:"damper-pedal,attr,omitempty" json:"damper-pedal,omitempty"`

	Soft_pedal *Yes_no_number `xml:"soft-pedal,attr,omitempty" json:"soft-pedal,omitempty"`

	Sostenuto_pedal *Yes_no_number `xml:"sostenuto-pedal,attr,omitempty" json:"sostenuto-pedal,omitempty"`
}

func CopyBranchSound 

func CopyBranchSound(mapOrigCopy map[any]any, soundFrom *Sound) (soundTo *Sound)

func (*Sound) Checkout 

func (sound *Sound) Checkout(stage *StageStruct) *Sound

Checkout sound to the back repo (if it is already staged)

func (*Sound) Commit 

func (sound *Sound) Commit(stage *StageStruct) *Sound

commit sound to the back repo (if it is already staged)

func (*Sound) CommitVoid 

func (sound *Sound) CommitVoid(stage *StageStruct)

func (*Sound) CopyBasicFields 

func (from *Sound) CopyBasicFields(to *Sound)

func (*Sound) GetName 

func (sound *Sound) GetName() (res string)

for satisfaction of GongStruct interface

func (*Sound) Stage 

func (sound *Sound) Stage(stage *StageStruct) *Sound

Stage puts sound to the model stage

func (*Sound) Unstage 

func (sound *Sound) Unstage(stage *StageStruct) *Sound

Unstage removes sound off the model stage

func (*Sound) UnstageVoid 

func (sound *Sound) UnstageVoid(stage *StageStruct)

UnstageVoid removes sound off the model stage

type Sound_WOP 

type Sound_WOP struct {
	// insertion point
	Name     string
	Segno    string
	Dalsegno string
	Coda     string
	Tocoda   string
	Fine     string
}

type Staff_details 

type Staff_details struct {
	Name       string
	Staff_type *Staff_type `xml:"staff-type,omitempty" json:"staff-type,omitempty"`

	Staff_tuning []*Staff_tuning `xml:"staff-tuning,omitempty" json:"staff-tuning,omitempty"`

	// The capo element indicates at which fret a capo should be
	// placed on a fretted instrument. This changes the open tuning of the strings
	// specified by staff-tuning by the specified number of half-steps.
	Capo uint32 `xml:"capo,omitempty" json:"capo,omitempty"`

	Staff_size *Staff_size `xml:"staff-size,omitempty" json:"staff-size,omitempty"`

	Number *Staff_number `xml:"number,attr,omitempty" json:"number,omitempty"`

	Show_frets *Show_frets `xml:"show-frets,attr,omitempty" json:"show-frets,omitempty"`
}

func CopyBranchStaff_details 

func CopyBranchStaff_details(mapOrigCopy map[any]any, staff_detailsFrom *Staff_details) (staff_detailsTo *Staff_details)

func (*Staff_details) Checkout 

func (staff_details *Staff_details) Checkout(stage *StageStruct) *Staff_details

Checkout staff_details to the back repo (if it is already staged)

func (*Staff_details) Commit 

func (staff_details *Staff_details) Commit(stage *StageStruct) *Staff_details

commit staff_details to the back repo (if it is already staged)

func (*Staff_details) CommitVoid 

func (staff_details *Staff_details) CommitVoid(stage *StageStruct)

func (*Staff_details) CopyBasicFields 

func (from *Staff_details) CopyBasicFields(to *Staff_details)

func (*Staff_details) GetName 

func (staff_details *Staff_details) GetName() (res string)

for satisfaction of GongStruct interface

func (*Staff_details) Stage 

func (staff_details *Staff_details) Stage(stage *StageStruct) *Staff_details

Stage puts staff_details to the model stage

func (*Staff_details) Unstage 

func (staff_details *Staff_details) Unstage(stage *StageStruct) *Staff_details

Unstage removes staff_details off the model stage

func (*Staff_details) UnstageVoid 

func (staff_details *Staff_details) UnstageVoid(stage *StageStruct)

UnstageVoid removes staff_details off the model stage

type Staff_details_WOP 

type Staff_details_WOP struct {
	// insertion point
	Name string
}

type Staff_divide 

type Staff_divide struct {
	Name string
	Type *Staff_divide_symbol `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchStaff_divide 

func CopyBranchStaff_divide(mapOrigCopy map[any]any, staff_divideFrom *Staff_divide) (staff_divideTo *Staff_divide)

func (*Staff_divide) Checkout 

func (staff_divide *Staff_divide) Checkout(stage *StageStruct) *Staff_divide

Checkout staff_divide to the back repo (if it is already staged)

func (*Staff_divide) Commit 

func (staff_divide *Staff_divide) Commit(stage *StageStruct) *Staff_divide

commit staff_divide to the back repo (if it is already staged)

func (*Staff_divide) CommitVoid 

func (staff_divide *Staff_divide) CommitVoid(stage *StageStruct)

func (*Staff_divide) CopyBasicFields 

func (from *Staff_divide) CopyBasicFields(to *Staff_divide)

func (*Staff_divide) GetName 

func (staff_divide *Staff_divide) GetName() (res string)

for satisfaction of GongStruct interface

func (*Staff_divide) Stage 

func (staff_divide *Staff_divide) Stage(stage *StageStruct) *Staff_divide

Stage puts staff_divide to the model stage

func (*Staff_divide) Unstage 

func (staff_divide *Staff_divide) Unstage(stage *StageStruct) *Staff_divide

Unstage removes staff_divide off the model stage

func (*Staff_divide) UnstageVoid 

func (staff_divide *Staff_divide) UnstageVoid(stage *StageStruct)

UnstageVoid removes staff_divide off the model stage

type Staff_divide_WOP 

type Staff_divide_WOP struct {
	// insertion point
	Name string
}

type Staff_divide_symbol 

type Staff_divide_symbol string
const (
	Staff_divide_symbolDown Staff_divide_symbol = "down"

	Staff_divide_symbolUp Staff_divide_symbol = "up"

	Staff_divide_symbolUp_down Staff_divide_symbol = "up-down"
)

func (Staff_divide_symbol) CodeValues 

func (staff_divide_symbol Staff_divide_symbol) CodeValues() (res []string)

func (Staff_divide_symbol) Codes 

func (staff_divide_symbol Staff_divide_symbol) Codes() (res []string)

func (*Staff_divide_symbol) FromCodeString 

func (staff_divide_symbol *Staff_divide_symbol) FromCodeString(input string) (err error)

func (*Staff_divide_symbol) FromString 

func (staff_divide_symbol *Staff_divide_symbol) FromString(input string) (err error)

func (*Staff_divide_symbol) ToCodeString 

func (staff_divide_symbol *Staff_divide_symbol) ToCodeString() (res string)

func (Staff_divide_symbol) ToString 

func (staff_divide_symbol Staff_divide_symbol) ToString() (res string)

Utility function for Staff_divide_symbol if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Staff_layout 

type Staff_layout struct {
	Name           string
	Staff_distance *Tenths `xml:"staff-distance,omitempty" json:"staff-distance,omitempty"`

	Number *Staff_number `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchStaff_layout 

func CopyBranchStaff_layout(mapOrigCopy map[any]any, staff_layoutFrom *Staff_layout) (staff_layoutTo *Staff_layout)

func (*Staff_layout) Checkout 

func (staff_layout *Staff_layout) Checkout(stage *StageStruct) *Staff_layout

Checkout staff_layout to the back repo (if it is already staged)

func (*Staff_layout) Commit 

func (staff_layout *Staff_layout) Commit(stage *StageStruct) *Staff_layout

commit staff_layout to the back repo (if it is already staged)

func (*Staff_layout) CommitVoid 

func (staff_layout *Staff_layout) CommitVoid(stage *StageStruct)

func (*Staff_layout) CopyBasicFields 

func (from *Staff_layout) CopyBasicFields(to *Staff_layout)

func (*Staff_layout) GetName 

func (staff_layout *Staff_layout) GetName() (res string)

for satisfaction of GongStruct interface

func (*Staff_layout) Stage 

func (staff_layout *Staff_layout) Stage(stage *StageStruct) *Staff_layout

Stage puts staff_layout to the model stage

func (*Staff_layout) Unstage 

func (staff_layout *Staff_layout) Unstage(stage *StageStruct) *Staff_layout

Unstage removes staff_layout off the model stage

func (*Staff_layout) UnstageVoid 

func (staff_layout *Staff_layout) UnstageVoid(stage *StageStruct)

UnstageVoid removes staff_layout off the model stage

type Staff_layout_WOP 

type Staff_layout_WOP struct {
	// insertion point
	Name string
}

type Staff_line 

type Staff_line PositiveInteger

type Staff_line_position 

type Staff_line_position int32

type Staff_number 

type Staff_number PositiveInteger

type Staff_size 

type Staff_size struct {
	Name  string
	Value *Non_negative_decimal `xml:",chardata" json:"-,"`

	Scaling *Non_negative_decimal `xml:"scaling,attr,omitempty" json:"scaling,omitempty"`
}

func CopyBranchStaff_size 

func CopyBranchStaff_size(mapOrigCopy map[any]any, staff_sizeFrom *Staff_size) (staff_sizeTo *Staff_size)

func (*Staff_size) Checkout 

func (staff_size *Staff_size) Checkout(stage *StageStruct) *Staff_size

Checkout staff_size to the back repo (if it is already staged)

func (*Staff_size) Commit 

func (staff_size *Staff_size) Commit(stage *StageStruct) *Staff_size

commit staff_size to the back repo (if it is already staged)

func (*Staff_size) CommitVoid 

func (staff_size *Staff_size) CommitVoid(stage *StageStruct)

func (*Staff_size) CopyBasicFields 

func (from *Staff_size) CopyBasicFields(to *Staff_size)

func (*Staff_size) GetName 

func (staff_size *Staff_size) GetName() (res string)

for satisfaction of GongStruct interface

func (*Staff_size) Stage 

func (staff_size *Staff_size) Stage(stage *StageStruct) *Staff_size

Stage puts staff_size to the model stage

func (*Staff_size) Unstage 

func (staff_size *Staff_size) Unstage(stage *StageStruct) *Staff_size

Unstage removes staff_size off the model stage

func (*Staff_size) UnstageVoid 

func (staff_size *Staff_size) UnstageVoid(stage *StageStruct)

UnstageVoid removes staff_size off the model stage

type Staff_size_WOP 

type Staff_size_WOP struct {
	// insertion point
	Name string
}

type Staff_tuning 

type Staff_tuning struct {
	Name string
	Line *Staff_line `xml:"line,attr,omitempty" json:"line,omitempty"`
}

func CopyBranchStaff_tuning 

func CopyBranchStaff_tuning(mapOrigCopy map[any]any, staff_tuningFrom *Staff_tuning) (staff_tuningTo *Staff_tuning)

func (*Staff_tuning) Checkout 

func (staff_tuning *Staff_tuning) Checkout(stage *StageStruct) *Staff_tuning

Checkout staff_tuning to the back repo (if it is already staged)

func (*Staff_tuning) Commit 

func (staff_tuning *Staff_tuning) Commit(stage *StageStruct) *Staff_tuning

commit staff_tuning to the back repo (if it is already staged)

func (*Staff_tuning) CommitVoid 

func (staff_tuning *Staff_tuning) CommitVoid(stage *StageStruct)

func (*Staff_tuning) CopyBasicFields 

func (from *Staff_tuning) CopyBasicFields(to *Staff_tuning)

func (*Staff_tuning) GetName 

func (staff_tuning *Staff_tuning) GetName() (res string)

for satisfaction of GongStruct interface

func (*Staff_tuning) Stage 

func (staff_tuning *Staff_tuning) Stage(stage *StageStruct) *Staff_tuning

Stage puts staff_tuning to the model stage

func (*Staff_tuning) Unstage 

func (staff_tuning *Staff_tuning) Unstage(stage *StageStruct) *Staff_tuning

Unstage removes staff_tuning off the model stage

func (*Staff_tuning) UnstageVoid 

func (staff_tuning *Staff_tuning) UnstageVoid(stage *StageStruct)

UnstageVoid removes staff_tuning off the model stage

type Staff_tuning_WOP 

type Staff_tuning_WOP struct {
	// insertion point
	Name string
}

type Staff_type 

type Staff_type string
const (
	Staff_typeOssia Staff_type = "ossia"

	Staff_typeEditorial Staff_type = "editorial"

	Staff_typeCue Staff_type = "cue"

	Staff_typeAlternate Staff_type = "alternate"

	Staff_typeRegular Staff_type = "regular"
)

func (Staff_type) CodeValues 

func (staff_type Staff_type) CodeValues() (res []string)

func (Staff_type) Codes 

func (staff_type Staff_type) Codes() (res []string)

func (*Staff_type) FromCodeString 

func (staff_type *Staff_type) FromCodeString(input string) (err error)

func (*Staff_type) FromString 

func (staff_type *Staff_type) FromString(input string) (err error)

func (*Staff_type) ToCodeString 

func (staff_type *Staff_type) ToCodeString() (res string)

func (Staff_type) ToString 

func (staff_type Staff_type) ToString() (res string)

Utility function for Staff_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type StageStruct 

type StageStruct struct {

	// insertion point for definition of arrays registering instances
	Accidentals           map[*Accidental]any
	Accidentals_mapString map[string]*Accidental

	OnAfterAccidentalCreateCallback OnAfterCreateInterface[Accidental]
	OnAfterAccidentalUpdateCallback OnAfterUpdateInterface[Accidental]
	OnAfterAccidentalDeleteCallback OnAfterDeleteInterface[Accidental]
	OnAfterAccidentalReadCallback   OnAfterReadInterface[Accidental]

	Accidental_marks           map[*Accidental_mark]any
	Accidental_marks_mapString map[string]*Accidental_mark

	OnAfterAccidental_markCreateCallback OnAfterCreateInterface[Accidental_mark]
	OnAfterAccidental_markUpdateCallback OnAfterUpdateInterface[Accidental_mark]
	OnAfterAccidental_markDeleteCallback OnAfterDeleteInterface[Accidental_mark]
	OnAfterAccidental_markReadCallback   OnAfterReadInterface[Accidental_mark]

	Accidental_texts           map[*Accidental_text]any
	Accidental_texts_mapString map[string]*Accidental_text

	OnAfterAccidental_textCreateCallback OnAfterCreateInterface[Accidental_text]
	OnAfterAccidental_textUpdateCallback OnAfterUpdateInterface[Accidental_text]
	OnAfterAccidental_textDeleteCallback OnAfterDeleteInterface[Accidental_text]
	OnAfterAccidental_textReadCallback   OnAfterReadInterface[Accidental_text]

	Accords           map[*Accord]any
	Accords_mapString map[string]*Accord

	OnAfterAccordCreateCallback OnAfterCreateInterface[Accord]
	OnAfterAccordUpdateCallback OnAfterUpdateInterface[Accord]
	OnAfterAccordDeleteCallback OnAfterDeleteInterface[Accord]
	OnAfterAccordReadCallback   OnAfterReadInterface[Accord]

	Accordion_registrations           map[*Accordion_registration]any
	Accordion_registrations_mapString map[string]*Accordion_registration

	OnAfterAccordion_registrationCreateCallback OnAfterCreateInterface[Accordion_registration]
	OnAfterAccordion_registrationUpdateCallback OnAfterUpdateInterface[Accordion_registration]
	OnAfterAccordion_registrationDeleteCallback OnAfterDeleteInterface[Accordion_registration]
	OnAfterAccordion_registrationReadCallback   OnAfterReadInterface[Accordion_registration]

	AnyTypes           map[*AnyType]any
	AnyTypes_mapString map[string]*AnyType

	OnAfterAnyTypeCreateCallback OnAfterCreateInterface[AnyType]
	OnAfterAnyTypeUpdateCallback OnAfterUpdateInterface[AnyType]
	OnAfterAnyTypeDeleteCallback OnAfterDeleteInterface[AnyType]
	OnAfterAnyTypeReadCallback   OnAfterReadInterface[AnyType]

	Appearances           map[*Appearance]any
	Appearances_mapString map[string]*Appearance

	// insertion point for slice of pointers maps
	Appearance_Line_width_reverseMap       map[*Line_width]*Appearance
	Appearance_Note_size_reverseMap        map[*Note_size]*Appearance
	Appearance_Distance_reverseMap         map[*Distance]*Appearance
	Appearance_Glyph_reverseMap            map[*Glyph]*Appearance
	Appearance_Other_appearance_reverseMap map[*Other_appearance]*Appearance

	OnAfterAppearanceCreateCallback OnAfterCreateInterface[Appearance]
	OnAfterAppearanceUpdateCallback OnAfterUpdateInterface[Appearance]
	OnAfterAppearanceDeleteCallback OnAfterDeleteInterface[Appearance]
	OnAfterAppearanceReadCallback   OnAfterReadInterface[Appearance]

	Arpeggiates           map[*Arpeggiate]any
	Arpeggiates_mapString map[string]*Arpeggiate

	OnAfterArpeggiateCreateCallback OnAfterCreateInterface[Arpeggiate]
	OnAfterArpeggiateUpdateCallback OnAfterUpdateInterface[Arpeggiate]
	OnAfterArpeggiateDeleteCallback OnAfterDeleteInterface[Arpeggiate]
	OnAfterArpeggiateReadCallback   OnAfterReadInterface[Arpeggiate]

	Arrows           map[*Arrow]any
	Arrows_mapString map[string]*Arrow

	OnAfterArrowCreateCallback OnAfterCreateInterface[Arrow]
	OnAfterArrowUpdateCallback OnAfterUpdateInterface[Arrow]
	OnAfterArrowDeleteCallback OnAfterDeleteInterface[Arrow]
	OnAfterArrowReadCallback   OnAfterReadInterface[Arrow]

	Articulationss           map[*Articulations]any
	Articulationss_mapString map[string]*Articulations

	OnAfterArticulationsCreateCallback OnAfterCreateInterface[Articulations]
	OnAfterArticulationsUpdateCallback OnAfterUpdateInterface[Articulations]
	OnAfterArticulationsDeleteCallback OnAfterDeleteInterface[Articulations]
	OnAfterArticulationsReadCallback   OnAfterReadInterface[Articulations]

	Assesss           map[*Assess]any
	Assesss_mapString map[string]*Assess

	OnAfterAssessCreateCallback OnAfterCreateInterface[Assess]
	OnAfterAssessUpdateCallback OnAfterUpdateInterface[Assess]
	OnAfterAssessDeleteCallback OnAfterDeleteInterface[Assess]
	OnAfterAssessReadCallback   OnAfterReadInterface[Assess]

	Attributess           map[*Attributes]any
	Attributess_mapString map[string]*Attributes

	// insertion point for slice of pointers maps
	Attributes_Key_reverseMap           map[*Key]*Attributes
	Attributes_Clef_reverseMap          map[*Clef]*Attributes
	Attributes_Staff_details_reverseMap map[*Staff_details]*Attributes
	Attributes_Measure_style_reverseMap map[*Measure_style]*Attributes
	Attributes_Transpose_reverseMap     map[*Transpose]*Attributes
	Attributes_For_part_reverseMap      map[*For_part]*Attributes

	OnAfterAttributesCreateCallback OnAfterCreateInterface[Attributes]
	OnAfterAttributesUpdateCallback OnAfterUpdateInterface[Attributes]
	OnAfterAttributesDeleteCallback OnAfterDeleteInterface[Attributes]
	OnAfterAttributesReadCallback   OnAfterReadInterface[Attributes]

	Backups           map[*Backup]any
	Backups_mapString map[string]*Backup

	OnAfterBackupCreateCallback OnAfterCreateInterface[Backup]
	OnAfterBackupUpdateCallback OnAfterUpdateInterface[Backup]
	OnAfterBackupDeleteCallback OnAfterDeleteInterface[Backup]
	OnAfterBackupReadCallback   OnAfterReadInterface[Backup]

	Bar_style_colors           map[*Bar_style_color]any
	Bar_style_colors_mapString map[string]*Bar_style_color

	OnAfterBar_style_colorCreateCallback OnAfterCreateInterface[Bar_style_color]
	OnAfterBar_style_colorUpdateCallback OnAfterUpdateInterface[Bar_style_color]
	OnAfterBar_style_colorDeleteCallback OnAfterDeleteInterface[Bar_style_color]
	OnAfterBar_style_colorReadCallback   OnAfterReadInterface[Bar_style_color]

	Barlines           map[*Barline]any
	Barlines_mapString map[string]*Barline

	OnAfterBarlineCreateCallback OnAfterCreateInterface[Barline]
	OnAfterBarlineUpdateCallback OnAfterUpdateInterface[Barline]
	OnAfterBarlineDeleteCallback OnAfterDeleteInterface[Barline]
	OnAfterBarlineReadCallback   OnAfterReadInterface[Barline]

	Barres           map[*Barre]any
	Barres_mapString map[string]*Barre

	OnAfterBarreCreateCallback OnAfterCreateInterface[Barre]
	OnAfterBarreUpdateCallback OnAfterUpdateInterface[Barre]
	OnAfterBarreDeleteCallback OnAfterDeleteInterface[Barre]
	OnAfterBarreReadCallback   OnAfterReadInterface[Barre]

	Basss           map[*Bass]any
	Basss_mapString map[string]*Bass

	OnAfterBassCreateCallback OnAfterCreateInterface[Bass]
	OnAfterBassUpdateCallback OnAfterUpdateInterface[Bass]
	OnAfterBassDeleteCallback OnAfterDeleteInterface[Bass]
	OnAfterBassReadCallback   OnAfterReadInterface[Bass]

	Bass_steps           map[*Bass_step]any
	Bass_steps_mapString map[string]*Bass_step

	OnAfterBass_stepCreateCallback OnAfterCreateInterface[Bass_step]
	OnAfterBass_stepUpdateCallback OnAfterUpdateInterface[Bass_step]
	OnAfterBass_stepDeleteCallback OnAfterDeleteInterface[Bass_step]
	OnAfterBass_stepReadCallback   OnAfterReadInterface[Bass_step]

	Beams           map[*Beam]any
	Beams_mapString map[string]*Beam

	OnAfterBeamCreateCallback OnAfterCreateInterface[Beam]
	OnAfterBeamUpdateCallback OnAfterUpdateInterface[Beam]
	OnAfterBeamDeleteCallback OnAfterDeleteInterface[Beam]
	OnAfterBeamReadCallback   OnAfterReadInterface[Beam]

	Beat_repeats           map[*Beat_repeat]any
	Beat_repeats_mapString map[string]*Beat_repeat

	OnAfterBeat_repeatCreateCallback OnAfterCreateInterface[Beat_repeat]
	OnAfterBeat_repeatUpdateCallback OnAfterUpdateInterface[Beat_repeat]
	OnAfterBeat_repeatDeleteCallback OnAfterDeleteInterface[Beat_repeat]
	OnAfterBeat_repeatReadCallback   OnAfterReadInterface[Beat_repeat]

	Beat_unit_tieds           map[*Beat_unit_tied]any
	Beat_unit_tieds_mapString map[string]*Beat_unit_tied

	OnAfterBeat_unit_tiedCreateCallback OnAfterCreateInterface[Beat_unit_tied]
	OnAfterBeat_unit_tiedUpdateCallback OnAfterUpdateInterface[Beat_unit_tied]
	OnAfterBeat_unit_tiedDeleteCallback OnAfterDeleteInterface[Beat_unit_tied]
	OnAfterBeat_unit_tiedReadCallback   OnAfterReadInterface[Beat_unit_tied]

	Beaters           map[*Beater]any
	Beaters_mapString map[string]*Beater

	OnAfterBeaterCreateCallback OnAfterCreateInterface[Beater]
	OnAfterBeaterUpdateCallback OnAfterUpdateInterface[Beater]
	OnAfterBeaterDeleteCallback OnAfterDeleteInterface[Beater]
	OnAfterBeaterReadCallback   OnAfterReadInterface[Beater]

	Bends           map[*Bend]any
	Bends_mapString map[string]*Bend

	OnAfterBendCreateCallback OnAfterCreateInterface[Bend]
	OnAfterBendUpdateCallback OnAfterUpdateInterface[Bend]
	OnAfterBendDeleteCallback OnAfterDeleteInterface[Bend]
	OnAfterBendReadCallback   OnAfterReadInterface[Bend]

	Bookmarks           map[*Bookmark]any
	Bookmarks_mapString map[string]*Bookmark

	OnAfterBookmarkCreateCallback OnAfterCreateInterface[Bookmark]
	OnAfterBookmarkUpdateCallback OnAfterUpdateInterface[Bookmark]
	OnAfterBookmarkDeleteCallback OnAfterDeleteInterface[Bookmark]
	OnAfterBookmarkReadCallback   OnAfterReadInterface[Bookmark]

	Brackets           map[*Bracket]any
	Brackets_mapString map[string]*Bracket

	OnAfterBracketCreateCallback OnAfterCreateInterface[Bracket]
	OnAfterBracketUpdateCallback OnAfterUpdateInterface[Bracket]
	OnAfterBracketDeleteCallback OnAfterDeleteInterface[Bracket]
	OnAfterBracketReadCallback   OnAfterReadInterface[Bracket]

	Breath_marks           map[*Breath_mark]any
	Breath_marks_mapString map[string]*Breath_mark

	OnAfterBreath_markCreateCallback OnAfterCreateInterface[Breath_mark]
	OnAfterBreath_markUpdateCallback OnAfterUpdateInterface[Breath_mark]
	OnAfterBreath_markDeleteCallback OnAfterDeleteInterface[Breath_mark]
	OnAfterBreath_markReadCallback   OnAfterReadInterface[Breath_mark]

	Caesuras           map[*Caesura]any
	Caesuras_mapString map[string]*Caesura

	OnAfterCaesuraCreateCallback OnAfterCreateInterface[Caesura]
	OnAfterCaesuraUpdateCallback OnAfterUpdateInterface[Caesura]
	OnAfterCaesuraDeleteCallback OnAfterDeleteInterface[Caesura]
	OnAfterCaesuraReadCallback   OnAfterReadInterface[Caesura]

	Cancels           map[*Cancel]any
	Cancels_mapString map[string]*Cancel

	OnAfterCancelCreateCallback OnAfterCreateInterface[Cancel]
	OnAfterCancelUpdateCallback OnAfterUpdateInterface[Cancel]
	OnAfterCancelDeleteCallback OnAfterDeleteInterface[Cancel]
	OnAfterCancelReadCallback   OnAfterReadInterface[Cancel]

	Clefs           map[*Clef]any
	Clefs_mapString map[string]*Clef

	OnAfterClefCreateCallback OnAfterCreateInterface[Clef]
	OnAfterClefUpdateCallback OnAfterUpdateInterface[Clef]
	OnAfterClefDeleteCallback OnAfterDeleteInterface[Clef]
	OnAfterClefReadCallback   OnAfterReadInterface[Clef]

	Codas           map[*Coda]any
	Codas_mapString map[string]*Coda

	OnAfterCodaCreateCallback OnAfterCreateInterface[Coda]
	OnAfterCodaUpdateCallback OnAfterUpdateInterface[Coda]
	OnAfterCodaDeleteCallback OnAfterDeleteInterface[Coda]
	OnAfterCodaReadCallback   OnAfterReadInterface[Coda]

	Credits           map[*Credit]any
	Credits_mapString map[string]*Credit

	// insertion point for slice of pointers maps
	Credit_Link_reverseMap     map[*Link]*Credit
	Credit_Bookmark_reverseMap map[*Bookmark]*Credit

	OnAfterCreditCreateCallback OnAfterCreateInterface[Credit]
	OnAfterCreditUpdateCallback OnAfterUpdateInterface[Credit]
	OnAfterCreditDeleteCallback OnAfterDeleteInterface[Credit]
	OnAfterCreditReadCallback   OnAfterReadInterface[Credit]

	Dashess           map[*Dashes]any
	Dashess_mapString map[string]*Dashes

	OnAfterDashesCreateCallback OnAfterCreateInterface[Dashes]
	OnAfterDashesUpdateCallback OnAfterUpdateInterface[Dashes]
	OnAfterDashesDeleteCallback OnAfterDeleteInterface[Dashes]
	OnAfterDashesReadCallback   OnAfterReadInterface[Dashes]

	Defaultss           map[*Defaults]any
	Defaultss_mapString map[string]*Defaults

	// insertion point for slice of pointers maps
	Defaults_Lyric_font_reverseMap     map[*Lyric_font]*Defaults
	Defaults_Lyric_language_reverseMap map[*Lyric_language]*Defaults

	OnAfterDefaultsCreateCallback OnAfterCreateInterface[Defaults]
	OnAfterDefaultsUpdateCallback OnAfterUpdateInterface[Defaults]
	OnAfterDefaultsDeleteCallback OnAfterDeleteInterface[Defaults]
	OnAfterDefaultsReadCallback   OnAfterReadInterface[Defaults]

	Degrees           map[*Degree]any
	Degrees_mapString map[string]*Degree

	OnAfterDegreeCreateCallback OnAfterCreateInterface[Degree]
	OnAfterDegreeUpdateCallback OnAfterUpdateInterface[Degree]
	OnAfterDegreeDeleteCallback OnAfterDeleteInterface[Degree]
	OnAfterDegreeReadCallback   OnAfterReadInterface[Degree]

	Degree_alters           map[*Degree_alter]any
	Degree_alters_mapString map[string]*Degree_alter

	OnAfterDegree_alterCreateCallback OnAfterCreateInterface[Degree_alter]
	OnAfterDegree_alterUpdateCallback OnAfterUpdateInterface[Degree_alter]
	OnAfterDegree_alterDeleteCallback OnAfterDeleteInterface[Degree_alter]
	OnAfterDegree_alterReadCallback   OnAfterReadInterface[Degree_alter]

	Degree_types           map[*Degree_type]any
	Degree_types_mapString map[string]*Degree_type

	OnAfterDegree_typeCreateCallback OnAfterCreateInterface[Degree_type]
	OnAfterDegree_typeUpdateCallback OnAfterUpdateInterface[Degree_type]
	OnAfterDegree_typeDeleteCallback OnAfterDeleteInterface[Degree_type]
	OnAfterDegree_typeReadCallback   OnAfterReadInterface[Degree_type]

	Degree_values           map[*Degree_value]any
	Degree_values_mapString map[string]*Degree_value

	OnAfterDegree_valueCreateCallback OnAfterCreateInterface[Degree_value]
	OnAfterDegree_valueUpdateCallback OnAfterUpdateInterface[Degree_value]
	OnAfterDegree_valueDeleteCallback OnAfterDeleteInterface[Degree_value]
	OnAfterDegree_valueReadCallback   OnAfterReadInterface[Degree_value]

	Directions           map[*Direction]any
	Directions_mapString map[string]*Direction

	// insertion point for slice of pointers maps
	Direction_Direction_type_reverseMap map[*Direction_type]*Direction

	OnAfterDirectionCreateCallback OnAfterCreateInterface[Direction]
	OnAfterDirectionUpdateCallback OnAfterUpdateInterface[Direction]
	OnAfterDirectionDeleteCallback OnAfterDeleteInterface[Direction]
	OnAfterDirectionReadCallback   OnAfterReadInterface[Direction]

	Direction_types           map[*Direction_type]any
	Direction_types_mapString map[string]*Direction_type

	// insertion point for slice of pointers maps
	Direction_type_Segno_reverseMap      map[*Segno]*Direction_type
	Direction_type_Coda_reverseMap       map[*Coda]*Direction_type
	Direction_type_Dynamics_reverseMap   map[*Dynamics]*Direction_type
	Direction_type_Percussion_reverseMap map[*Percussion]*Direction_type

	OnAfterDirection_typeCreateCallback OnAfterCreateInterface[Direction_type]
	OnAfterDirection_typeUpdateCallback OnAfterUpdateInterface[Direction_type]
	OnAfterDirection_typeDeleteCallback OnAfterDeleteInterface[Direction_type]
	OnAfterDirection_typeReadCallback   OnAfterReadInterface[Direction_type]

	Distances           map[*Distance]any
	Distances_mapString map[string]*Distance

	OnAfterDistanceCreateCallback OnAfterCreateInterface[Distance]
	OnAfterDistanceUpdateCallback OnAfterUpdateInterface[Distance]
	OnAfterDistanceDeleteCallback OnAfterDeleteInterface[Distance]
	OnAfterDistanceReadCallback   OnAfterReadInterface[Distance]

	Doubles           map[*Double]any
	Doubles_mapString map[string]*Double

	OnAfterDoubleCreateCallback OnAfterCreateInterface[Double]
	OnAfterDoubleUpdateCallback OnAfterUpdateInterface[Double]
	OnAfterDoubleDeleteCallback OnAfterDeleteInterface[Double]
	OnAfterDoubleReadCallback   OnAfterReadInterface[Double]

	Dynamicss           map[*Dynamics]any
	Dynamicss_mapString map[string]*Dynamics

	OnAfterDynamicsCreateCallback OnAfterCreateInterface[Dynamics]
	OnAfterDynamicsUpdateCallback OnAfterUpdateInterface[Dynamics]
	OnAfterDynamicsDeleteCallback OnAfterDeleteInterface[Dynamics]
	OnAfterDynamicsReadCallback   OnAfterReadInterface[Dynamics]

	Effects           map[*Effect]any
	Effects_mapString map[string]*Effect

	OnAfterEffectCreateCallback OnAfterCreateInterface[Effect]
	OnAfterEffectUpdateCallback OnAfterUpdateInterface[Effect]
	OnAfterEffectDeleteCallback OnAfterDeleteInterface[Effect]
	OnAfterEffectReadCallback   OnAfterReadInterface[Effect]

	Elisions           map[*Elision]any
	Elisions_mapString map[string]*Elision

	OnAfterElisionCreateCallback OnAfterCreateInterface[Elision]
	OnAfterElisionUpdateCallback OnAfterUpdateInterface[Elision]
	OnAfterElisionDeleteCallback OnAfterDeleteInterface[Elision]
	OnAfterElisionReadCallback   OnAfterReadInterface[Elision]

	Emptys           map[*Empty]any
	Emptys_mapString map[string]*Empty

	OnAfterEmptyCreateCallback OnAfterCreateInterface[Empty]
	OnAfterEmptyUpdateCallback OnAfterUpdateInterface[Empty]
	OnAfterEmptyDeleteCallback OnAfterDeleteInterface[Empty]
	OnAfterEmptyReadCallback   OnAfterReadInterface[Empty]

	Empty_fonts           map[*Empty_font]any
	Empty_fonts_mapString map[string]*Empty_font

	OnAfterEmpty_fontCreateCallback OnAfterCreateInterface[Empty_font]
	OnAfterEmpty_fontUpdateCallback OnAfterUpdateInterface[Empty_font]
	OnAfterEmpty_fontDeleteCallback OnAfterDeleteInterface[Empty_font]
	OnAfterEmpty_fontReadCallback   OnAfterReadInterface[Empty_font]

	Empty_lines           map[*Empty_line]any
	Empty_lines_mapString map[string]*Empty_line

	OnAfterEmpty_lineCreateCallback OnAfterCreateInterface[Empty_line]
	OnAfterEmpty_lineUpdateCallback OnAfterUpdateInterface[Empty_line]
	OnAfterEmpty_lineDeleteCallback OnAfterDeleteInterface[Empty_line]
	OnAfterEmpty_lineReadCallback   OnAfterReadInterface[Empty_line]

	Empty_placements           map[*Empty_placement]any
	Empty_placements_mapString map[string]*Empty_placement

	OnAfterEmpty_placementCreateCallback OnAfterCreateInterface[Empty_placement]
	OnAfterEmpty_placementUpdateCallback OnAfterUpdateInterface[Empty_placement]
	OnAfterEmpty_placementDeleteCallback OnAfterDeleteInterface[Empty_placement]
	OnAfterEmpty_placementReadCallback   OnAfterReadInterface[Empty_placement]

	Empty_placement_smufls           map[*Empty_placement_smufl]any
	Empty_placement_smufls_mapString map[string]*Empty_placement_smufl

	OnAfterEmpty_placement_smuflCreateCallback OnAfterCreateInterface[Empty_placement_smufl]
	OnAfterEmpty_placement_smuflUpdateCallback OnAfterUpdateInterface[Empty_placement_smufl]
	OnAfterEmpty_placement_smuflDeleteCallback OnAfterDeleteInterface[Empty_placement_smufl]
	OnAfterEmpty_placement_smuflReadCallback   OnAfterReadInterface[Empty_placement_smufl]

	Empty_print_object_style_aligns           map[*Empty_print_object_style_align]any
	Empty_print_object_style_aligns_mapString map[string]*Empty_print_object_style_align

	OnAfterEmpty_print_object_style_alignCreateCallback OnAfterCreateInterface[Empty_print_object_style_align]
	OnAfterEmpty_print_object_style_alignUpdateCallback OnAfterUpdateInterface[Empty_print_object_style_align]
	OnAfterEmpty_print_object_style_alignDeleteCallback OnAfterDeleteInterface[Empty_print_object_style_align]
	OnAfterEmpty_print_object_style_alignReadCallback   OnAfterReadInterface[Empty_print_object_style_align]

	Empty_print_styles           map[*Empty_print_style]any
	Empty_print_styles_mapString map[string]*Empty_print_style

	OnAfterEmpty_print_styleCreateCallback OnAfterCreateInterface[Empty_print_style]
	OnAfterEmpty_print_styleUpdateCallback OnAfterUpdateInterface[Empty_print_style]
	OnAfterEmpty_print_styleDeleteCallback OnAfterDeleteInterface[Empty_print_style]
	OnAfterEmpty_print_styleReadCallback   OnAfterReadInterface[Empty_print_style]

	Empty_print_style_aligns           map[*Empty_print_style_align]any
	Empty_print_style_aligns_mapString map[string]*Empty_print_style_align

	OnAfterEmpty_print_style_alignCreateCallback OnAfterCreateInterface[Empty_print_style_align]
	OnAfterEmpty_print_style_alignUpdateCallback OnAfterUpdateInterface[Empty_print_style_align]
	OnAfterEmpty_print_style_alignDeleteCallback OnAfterDeleteInterface[Empty_print_style_align]
	OnAfterEmpty_print_style_alignReadCallback   OnAfterReadInterface[Empty_print_style_align]

	Empty_print_style_align_ids           map[*Empty_print_style_align_id]any
	Empty_print_style_align_ids_mapString map[string]*Empty_print_style_align_id

	OnAfterEmpty_print_style_align_idCreateCallback OnAfterCreateInterface[Empty_print_style_align_id]
	OnAfterEmpty_print_style_align_idUpdateCallback OnAfterUpdateInterface[Empty_print_style_align_id]
	OnAfterEmpty_print_style_align_idDeleteCallback OnAfterDeleteInterface[Empty_print_style_align_id]
	OnAfterEmpty_print_style_align_idReadCallback   OnAfterReadInterface[Empty_print_style_align_id]

	Empty_trill_sounds           map[*Empty_trill_sound]any
	Empty_trill_sounds_mapString map[string]*Empty_trill_sound

	OnAfterEmpty_trill_soundCreateCallback OnAfterCreateInterface[Empty_trill_sound]
	OnAfterEmpty_trill_soundUpdateCallback OnAfterUpdateInterface[Empty_trill_sound]
	OnAfterEmpty_trill_soundDeleteCallback OnAfterDeleteInterface[Empty_trill_sound]
	OnAfterEmpty_trill_soundReadCallback   OnAfterReadInterface[Empty_trill_sound]

	Encodings           map[*Encoding]any
	Encodings_mapString map[string]*Encoding

	OnAfterEncodingCreateCallback OnAfterCreateInterface[Encoding]
	OnAfterEncodingUpdateCallback OnAfterUpdateInterface[Encoding]
	OnAfterEncodingDeleteCallback OnAfterDeleteInterface[Encoding]
	OnAfterEncodingReadCallback   OnAfterReadInterface[Encoding]

	Endings           map[*Ending]any
	Endings_mapString map[string]*Ending

	OnAfterEndingCreateCallback OnAfterCreateInterface[Ending]
	OnAfterEndingUpdateCallback OnAfterUpdateInterface[Ending]
	OnAfterEndingDeleteCallback OnAfterDeleteInterface[Ending]
	OnAfterEndingReadCallback   OnAfterReadInterface[Ending]

	Extends           map[*Extend]any
	Extends_mapString map[string]*Extend

	OnAfterExtendCreateCallback OnAfterCreateInterface[Extend]
	OnAfterExtendUpdateCallback OnAfterUpdateInterface[Extend]
	OnAfterExtendDeleteCallback OnAfterDeleteInterface[Extend]
	OnAfterExtendReadCallback   OnAfterReadInterface[Extend]

	Features           map[*Feature]any
	Features_mapString map[string]*Feature

	OnAfterFeatureCreateCallback OnAfterCreateInterface[Feature]
	OnAfterFeatureUpdateCallback OnAfterUpdateInterface[Feature]
	OnAfterFeatureDeleteCallback OnAfterDeleteInterface[Feature]
	OnAfterFeatureReadCallback   OnAfterReadInterface[Feature]

	Fermatas           map[*Fermata]any
	Fermatas_mapString map[string]*Fermata

	OnAfterFermataCreateCallback OnAfterCreateInterface[Fermata]
	OnAfterFermataUpdateCallback OnAfterUpdateInterface[Fermata]
	OnAfterFermataDeleteCallback OnAfterDeleteInterface[Fermata]
	OnAfterFermataReadCallback   OnAfterReadInterface[Fermata]

	Figures           map[*Figure]any
	Figures_mapString map[string]*Figure

	OnAfterFigureCreateCallback OnAfterCreateInterface[Figure]
	OnAfterFigureUpdateCallback OnAfterUpdateInterface[Figure]
	OnAfterFigureDeleteCallback OnAfterDeleteInterface[Figure]
	OnAfterFigureReadCallback   OnAfterReadInterface[Figure]

	Figured_basss           map[*Figured_bass]any
	Figured_basss_mapString map[string]*Figured_bass

	// insertion point for slice of pointers maps
	Figured_bass_Figure_reverseMap map[*Figure]*Figured_bass

	OnAfterFigured_bassCreateCallback OnAfterCreateInterface[Figured_bass]
	OnAfterFigured_bassUpdateCallback OnAfterUpdateInterface[Figured_bass]
	OnAfterFigured_bassDeleteCallback OnAfterDeleteInterface[Figured_bass]
	OnAfterFigured_bassReadCallback   OnAfterReadInterface[Figured_bass]

	Fingerings           map[*Fingering]any
	Fingerings_mapString map[string]*Fingering

	OnAfterFingeringCreateCallback OnAfterCreateInterface[Fingering]
	OnAfterFingeringUpdateCallback OnAfterUpdateInterface[Fingering]
	OnAfterFingeringDeleteCallback OnAfterDeleteInterface[Fingering]
	OnAfterFingeringReadCallback   OnAfterReadInterface[Fingering]

	First_frets           map[*First_fret]any
	First_frets_mapString map[string]*First_fret

	OnAfterFirst_fretCreateCallback OnAfterCreateInterface[First_fret]
	OnAfterFirst_fretUpdateCallback OnAfterUpdateInterface[First_fret]
	OnAfterFirst_fretDeleteCallback OnAfterDeleteInterface[First_fret]
	OnAfterFirst_fretReadCallback   OnAfterReadInterface[First_fret]

	Foos           map[*Foo]any
	Foos_mapString map[string]*Foo

	OnAfterFooCreateCallback OnAfterCreateInterface[Foo]
	OnAfterFooUpdateCallback OnAfterUpdateInterface[Foo]
	OnAfterFooDeleteCallback OnAfterDeleteInterface[Foo]
	OnAfterFooReadCallback   OnAfterReadInterface[Foo]

	For_parts           map[*For_part]any
	For_parts_mapString map[string]*For_part

	OnAfterFor_partCreateCallback OnAfterCreateInterface[For_part]
	OnAfterFor_partUpdateCallback OnAfterUpdateInterface[For_part]
	OnAfterFor_partDeleteCallback OnAfterDeleteInterface[For_part]
	OnAfterFor_partReadCallback   OnAfterReadInterface[For_part]

	Formatted_symbols           map[*Formatted_symbol]any
	Formatted_symbols_mapString map[string]*Formatted_symbol

	OnAfterFormatted_symbolCreateCallback OnAfterCreateInterface[Formatted_symbol]
	OnAfterFormatted_symbolUpdateCallback OnAfterUpdateInterface[Formatted_symbol]
	OnAfterFormatted_symbolDeleteCallback OnAfterDeleteInterface[Formatted_symbol]
	OnAfterFormatted_symbolReadCallback   OnAfterReadInterface[Formatted_symbol]

	Formatted_symbol_ids           map[*Formatted_symbol_id]any
	Formatted_symbol_ids_mapString map[string]*Formatted_symbol_id

	OnAfterFormatted_symbol_idCreateCallback OnAfterCreateInterface[Formatted_symbol_id]
	OnAfterFormatted_symbol_idUpdateCallback OnAfterUpdateInterface[Formatted_symbol_id]
	OnAfterFormatted_symbol_idDeleteCallback OnAfterDeleteInterface[Formatted_symbol_id]
	OnAfterFormatted_symbol_idReadCallback   OnAfterReadInterface[Formatted_symbol_id]

	Forwards           map[*Forward]any
	Forwards_mapString map[string]*Forward

	OnAfterForwardCreateCallback OnAfterCreateInterface[Forward]
	OnAfterForwardUpdateCallback OnAfterUpdateInterface[Forward]
	OnAfterForwardDeleteCallback OnAfterDeleteInterface[Forward]
	OnAfterForwardReadCallback   OnAfterReadInterface[Forward]

	Frames           map[*Frame]any
	Frames_mapString map[string]*Frame

	// insertion point for slice of pointers maps
	Frame_Frame_note_reverseMap map[*Frame_note]*Frame

	OnAfterFrameCreateCallback OnAfterCreateInterface[Frame]
	OnAfterFrameUpdateCallback OnAfterUpdateInterface[Frame]
	OnAfterFrameDeleteCallback OnAfterDeleteInterface[Frame]
	OnAfterFrameReadCallback   OnAfterReadInterface[Frame]

	Frame_notes           map[*Frame_note]any
	Frame_notes_mapString map[string]*Frame_note

	OnAfterFrame_noteCreateCallback OnAfterCreateInterface[Frame_note]
	OnAfterFrame_noteUpdateCallback OnAfterUpdateInterface[Frame_note]
	OnAfterFrame_noteDeleteCallback OnAfterDeleteInterface[Frame_note]
	OnAfterFrame_noteReadCallback   OnAfterReadInterface[Frame_note]

	Frets           map[*Fret]any
	Frets_mapString map[string]*Fret

	OnAfterFretCreateCallback OnAfterCreateInterface[Fret]
	OnAfterFretUpdateCallback OnAfterUpdateInterface[Fret]
	OnAfterFretDeleteCallback OnAfterDeleteInterface[Fret]
	OnAfterFretReadCallback   OnAfterReadInterface[Fret]

	Glasss           map[*Glass]any
	Glasss_mapString map[string]*Glass

	OnAfterGlassCreateCallback OnAfterCreateInterface[Glass]
	OnAfterGlassUpdateCallback OnAfterUpdateInterface[Glass]
	OnAfterGlassDeleteCallback OnAfterDeleteInterface[Glass]
	OnAfterGlassReadCallback   OnAfterReadInterface[Glass]

	Glissandos           map[*Glissando]any
	Glissandos_mapString map[string]*Glissando

	OnAfterGlissandoCreateCallback OnAfterCreateInterface[Glissando]
	OnAfterGlissandoUpdateCallback OnAfterUpdateInterface[Glissando]
	OnAfterGlissandoDeleteCallback OnAfterDeleteInterface[Glissando]
	OnAfterGlissandoReadCallback   OnAfterReadInterface[Glissando]

	Glyphs           map[*Glyph]any
	Glyphs_mapString map[string]*Glyph

	OnAfterGlyphCreateCallback OnAfterCreateInterface[Glyph]
	OnAfterGlyphUpdateCallback OnAfterUpdateInterface[Glyph]
	OnAfterGlyphDeleteCallback OnAfterDeleteInterface[Glyph]
	OnAfterGlyphReadCallback   OnAfterReadInterface[Glyph]

	Graces           map[*Grace]any
	Graces_mapString map[string]*Grace

	OnAfterGraceCreateCallback OnAfterCreateInterface[Grace]
	OnAfterGraceUpdateCallback OnAfterUpdateInterface[Grace]
	OnAfterGraceDeleteCallback OnAfterDeleteInterface[Grace]
	OnAfterGraceReadCallback   OnAfterReadInterface[Grace]

	Group_barlines           map[*Group_barline]any
	Group_barlines_mapString map[string]*Group_barline

	OnAfterGroup_barlineCreateCallback OnAfterCreateInterface[Group_barline]
	OnAfterGroup_barlineUpdateCallback OnAfterUpdateInterface[Group_barline]
	OnAfterGroup_barlineDeleteCallback OnAfterDeleteInterface[Group_barline]
	OnAfterGroup_barlineReadCallback   OnAfterReadInterface[Group_barline]

	Group_symbols           map[*Group_symbol]any
	Group_symbols_mapString map[string]*Group_symbol

	OnAfterGroup_symbolCreateCallback OnAfterCreateInterface[Group_symbol]
	OnAfterGroup_symbolUpdateCallback OnAfterUpdateInterface[Group_symbol]
	OnAfterGroup_symbolDeleteCallback OnAfterDeleteInterface[Group_symbol]
	OnAfterGroup_symbolReadCallback   OnAfterReadInterface[Group_symbol]

	Groupings           map[*Grouping]any
	Groupings_mapString map[string]*Grouping

	// insertion point for slice of pointers maps
	Grouping_Feature_reverseMap map[*Feature]*Grouping

	OnAfterGroupingCreateCallback OnAfterCreateInterface[Grouping]
	OnAfterGroupingUpdateCallback OnAfterUpdateInterface[Grouping]
	OnAfterGroupingDeleteCallback OnAfterDeleteInterface[Grouping]
	OnAfterGroupingReadCallback   OnAfterReadInterface[Grouping]

	Hammer_on_pull_offs           map[*Hammer_on_pull_off]any
	Hammer_on_pull_offs_mapString map[string]*Hammer_on_pull_off

	OnAfterHammer_on_pull_offCreateCallback OnAfterCreateInterface[Hammer_on_pull_off]
	OnAfterHammer_on_pull_offUpdateCallback OnAfterUpdateInterface[Hammer_on_pull_off]
	OnAfterHammer_on_pull_offDeleteCallback OnAfterDeleteInterface[Hammer_on_pull_off]
	OnAfterHammer_on_pull_offReadCallback   OnAfterReadInterface[Hammer_on_pull_off]

	Handbells           map[*Handbell]any
	Handbells_mapString map[string]*Handbell

	OnAfterHandbellCreateCallback OnAfterCreateInterface[Handbell]
	OnAfterHandbellUpdateCallback OnAfterUpdateInterface[Handbell]
	OnAfterHandbellDeleteCallback OnAfterDeleteInterface[Handbell]
	OnAfterHandbellReadCallback   OnAfterReadInterface[Handbell]

	Harmon_closeds           map[*Harmon_closed]any
	Harmon_closeds_mapString map[string]*Harmon_closed

	OnAfterHarmon_closedCreateCallback OnAfterCreateInterface[Harmon_closed]
	OnAfterHarmon_closedUpdateCallback OnAfterUpdateInterface[Harmon_closed]
	OnAfterHarmon_closedDeleteCallback OnAfterDeleteInterface[Harmon_closed]
	OnAfterHarmon_closedReadCallback   OnAfterReadInterface[Harmon_closed]

	Harmon_mutes           map[*Harmon_mute]any
	Harmon_mutes_mapString map[string]*Harmon_mute

	OnAfterHarmon_muteCreateCallback OnAfterCreateInterface[Harmon_mute]
	OnAfterHarmon_muteUpdateCallback OnAfterUpdateInterface[Harmon_mute]
	OnAfterHarmon_muteDeleteCallback OnAfterDeleteInterface[Harmon_mute]
	OnAfterHarmon_muteReadCallback   OnAfterReadInterface[Harmon_mute]

	Harmonics           map[*Harmonic]any
	Harmonics_mapString map[string]*Harmonic

	OnAfterHarmonicCreateCallback OnAfterCreateInterface[Harmonic]
	OnAfterHarmonicUpdateCallback OnAfterUpdateInterface[Harmonic]
	OnAfterHarmonicDeleteCallback OnAfterDeleteInterface[Harmonic]
	OnAfterHarmonicReadCallback   OnAfterReadInterface[Harmonic]

	Harmonys           map[*Harmony]any
	Harmonys_mapString map[string]*Harmony

	OnAfterHarmonyCreateCallback OnAfterCreateInterface[Harmony]
	OnAfterHarmonyUpdateCallback OnAfterUpdateInterface[Harmony]
	OnAfterHarmonyDeleteCallback OnAfterDeleteInterface[Harmony]
	OnAfterHarmonyReadCallback   OnAfterReadInterface[Harmony]

	Harmony_alters           map[*Harmony_alter]any
	Harmony_alters_mapString map[string]*Harmony_alter

	OnAfterHarmony_alterCreateCallback OnAfterCreateInterface[Harmony_alter]
	OnAfterHarmony_alterUpdateCallback OnAfterUpdateInterface[Harmony_alter]
	OnAfterHarmony_alterDeleteCallback OnAfterDeleteInterface[Harmony_alter]
	OnAfterHarmony_alterReadCallback   OnAfterReadInterface[Harmony_alter]

	Harp_pedalss           map[*Harp_pedals]any
	Harp_pedalss_mapString map[string]*Harp_pedals

	// insertion point for slice of pointers maps
	Harp_pedals_Pedal_tuning_reverseMap map[*Pedal_tuning]*Harp_pedals

	OnAfterHarp_pedalsCreateCallback OnAfterCreateInterface[Harp_pedals]
	OnAfterHarp_pedalsUpdateCallback OnAfterUpdateInterface[Harp_pedals]
	OnAfterHarp_pedalsDeleteCallback OnAfterDeleteInterface[Harp_pedals]
	OnAfterHarp_pedalsReadCallback   OnAfterReadInterface[Harp_pedals]

	Heel_toes           map[*Heel_toe]any
	Heel_toes_mapString map[string]*Heel_toe

	OnAfterHeel_toeCreateCallback OnAfterCreateInterface[Heel_toe]
	OnAfterHeel_toeUpdateCallback OnAfterUpdateInterface[Heel_toe]
	OnAfterHeel_toeDeleteCallback OnAfterDeleteInterface[Heel_toe]
	OnAfterHeel_toeReadCallback   OnAfterReadInterface[Heel_toe]

	Holes           map[*Hole]any
	Holes_mapString map[string]*Hole

	OnAfterHoleCreateCallback OnAfterCreateInterface[Hole]
	OnAfterHoleUpdateCallback OnAfterUpdateInterface[Hole]
	OnAfterHoleDeleteCallback OnAfterDeleteInterface[Hole]
	OnAfterHoleReadCallback   OnAfterReadInterface[Hole]

	Hole_closeds           map[*Hole_closed]any
	Hole_closeds_mapString map[string]*Hole_closed

	OnAfterHole_closedCreateCallback OnAfterCreateInterface[Hole_closed]
	OnAfterHole_closedUpdateCallback OnAfterUpdateInterface[Hole_closed]
	OnAfterHole_closedDeleteCallback OnAfterDeleteInterface[Hole_closed]
	OnAfterHole_closedReadCallback   OnAfterReadInterface[Hole_closed]

	Horizontal_turns           map[*Horizontal_turn]any
	Horizontal_turns_mapString map[string]*Horizontal_turn

	OnAfterHorizontal_turnCreateCallback OnAfterCreateInterface[Horizontal_turn]
	OnAfterHorizontal_turnUpdateCallback OnAfterUpdateInterface[Horizontal_turn]
	OnAfterHorizontal_turnDeleteCallback OnAfterDeleteInterface[Horizontal_turn]
	OnAfterHorizontal_turnReadCallback   OnAfterReadInterface[Horizontal_turn]

	Identifications           map[*Identification]any
	Identifications_mapString map[string]*Identification

	// insertion point for slice of pointers maps
	Identification_Creator_reverseMap  map[*Typed_text]*Identification
	Identification_Rights_reverseMap   map[*Typed_text]*Identification
	Identification_Relation_reverseMap map[*Typed_text]*Identification

	OnAfterIdentificationCreateCallback OnAfterCreateInterface[Identification]
	OnAfterIdentificationUpdateCallback OnAfterUpdateInterface[Identification]
	OnAfterIdentificationDeleteCallback OnAfterDeleteInterface[Identification]
	OnAfterIdentificationReadCallback   OnAfterReadInterface[Identification]

	Images           map[*Image]any
	Images_mapString map[string]*Image

	OnAfterImageCreateCallback OnAfterCreateInterface[Image]
	OnAfterImageUpdateCallback OnAfterUpdateInterface[Image]
	OnAfterImageDeleteCallback OnAfterDeleteInterface[Image]
	OnAfterImageReadCallback   OnAfterReadInterface[Image]

	Instruments           map[*Instrument]any
	Instruments_mapString map[string]*Instrument

	OnAfterInstrumentCreateCallback OnAfterCreateInterface[Instrument]
	OnAfterInstrumentUpdateCallback OnAfterUpdateInterface[Instrument]
	OnAfterInstrumentDeleteCallback OnAfterDeleteInterface[Instrument]
	OnAfterInstrumentReadCallback   OnAfterReadInterface[Instrument]

	Instrument_changes           map[*Instrument_change]any
	Instrument_changes_mapString map[string]*Instrument_change

	OnAfterInstrument_changeCreateCallback OnAfterCreateInterface[Instrument_change]
	OnAfterInstrument_changeUpdateCallback OnAfterUpdateInterface[Instrument_change]
	OnAfterInstrument_changeDeleteCallback OnAfterDeleteInterface[Instrument_change]
	OnAfterInstrument_changeReadCallback   OnAfterReadInterface[Instrument_change]

	Instrument_links           map[*Instrument_link]any
	Instrument_links_mapString map[string]*Instrument_link

	OnAfterInstrument_linkCreateCallback OnAfterCreateInterface[Instrument_link]
	OnAfterInstrument_linkUpdateCallback OnAfterUpdateInterface[Instrument_link]
	OnAfterInstrument_linkDeleteCallback OnAfterDeleteInterface[Instrument_link]
	OnAfterInstrument_linkReadCallback   OnAfterReadInterface[Instrument_link]

	Interchangeables           map[*Interchangeable]any
	Interchangeables_mapString map[string]*Interchangeable

	OnAfterInterchangeableCreateCallback OnAfterCreateInterface[Interchangeable]
	OnAfterInterchangeableUpdateCallback OnAfterUpdateInterface[Interchangeable]
	OnAfterInterchangeableDeleteCallback OnAfterDeleteInterface[Interchangeable]
	OnAfterInterchangeableReadCallback   OnAfterReadInterface[Interchangeable]

	Inversions           map[*Inversion]any
	Inversions_mapString map[string]*Inversion

	OnAfterInversionCreateCallback OnAfterCreateInterface[Inversion]
	OnAfterInversionUpdateCallback OnAfterUpdateInterface[Inversion]
	OnAfterInversionDeleteCallback OnAfterDeleteInterface[Inversion]
	OnAfterInversionReadCallback   OnAfterReadInterface[Inversion]

	Keys           map[*Key]any
	Keys_mapString map[string]*Key

	// insertion point for slice of pointers maps
	Key_Key_octave_reverseMap map[*Key_octave]*Key

	OnAfterKeyCreateCallback OnAfterCreateInterface[Key]
	OnAfterKeyUpdateCallback OnAfterUpdateInterface[Key]
	OnAfterKeyDeleteCallback OnAfterDeleteInterface[Key]
	OnAfterKeyReadCallback   OnAfterReadInterface[Key]

	Key_accidentals           map[*Key_accidental]any
	Key_accidentals_mapString map[string]*Key_accidental

	OnAfterKey_accidentalCreateCallback OnAfterCreateInterface[Key_accidental]
	OnAfterKey_accidentalUpdateCallback OnAfterUpdateInterface[Key_accidental]
	OnAfterKey_accidentalDeleteCallback OnAfterDeleteInterface[Key_accidental]
	OnAfterKey_accidentalReadCallback   OnAfterReadInterface[Key_accidental]

	Key_octaves           map[*Key_octave]any
	Key_octaves_mapString map[string]*Key_octave

	OnAfterKey_octaveCreateCallback OnAfterCreateInterface[Key_octave]
	OnAfterKey_octaveUpdateCallback OnAfterUpdateInterface[Key_octave]
	OnAfterKey_octaveDeleteCallback OnAfterDeleteInterface[Key_octave]
	OnAfterKey_octaveReadCallback   OnAfterReadInterface[Key_octave]

	Kinds           map[*Kind]any
	Kinds_mapString map[string]*Kind

	OnAfterKindCreateCallback OnAfterCreateInterface[Kind]
	OnAfterKindUpdateCallback OnAfterUpdateInterface[Kind]
	OnAfterKindDeleteCallback OnAfterDeleteInterface[Kind]
	OnAfterKindReadCallback   OnAfterReadInterface[Kind]

	Levels           map[*Level]any
	Levels_mapString map[string]*Level

	OnAfterLevelCreateCallback OnAfterCreateInterface[Level]
	OnAfterLevelUpdateCallback OnAfterUpdateInterface[Level]
	OnAfterLevelDeleteCallback OnAfterDeleteInterface[Level]
	OnAfterLevelReadCallback   OnAfterReadInterface[Level]

	Line_details           map[*Line_detail]any
	Line_details_mapString map[string]*Line_detail

	OnAfterLine_detailCreateCallback OnAfterCreateInterface[Line_detail]
	OnAfterLine_detailUpdateCallback OnAfterUpdateInterface[Line_detail]
	OnAfterLine_detailDeleteCallback OnAfterDeleteInterface[Line_detail]
	OnAfterLine_detailReadCallback   OnAfterReadInterface[Line_detail]

	Line_widths           map[*Line_width]any
	Line_widths_mapString map[string]*Line_width

	OnAfterLine_widthCreateCallback OnAfterCreateInterface[Line_width]
	OnAfterLine_widthUpdateCallback OnAfterUpdateInterface[Line_width]
	OnAfterLine_widthDeleteCallback OnAfterDeleteInterface[Line_width]
	OnAfterLine_widthReadCallback   OnAfterReadInterface[Line_width]

	Links           map[*Link]any
	Links_mapString map[string]*Link

	OnAfterLinkCreateCallback OnAfterCreateInterface[Link]
	OnAfterLinkUpdateCallback OnAfterUpdateInterface[Link]
	OnAfterLinkDeleteCallback OnAfterDeleteInterface[Link]
	OnAfterLinkReadCallback   OnAfterReadInterface[Link]

	Listens           map[*Listen]any
	Listens_mapString map[string]*Listen

	OnAfterListenCreateCallback OnAfterCreateInterface[Listen]
	OnAfterListenUpdateCallback OnAfterUpdateInterface[Listen]
	OnAfterListenDeleteCallback OnAfterDeleteInterface[Listen]
	OnAfterListenReadCallback   OnAfterReadInterface[Listen]

	Listenings           map[*Listening]any
	Listenings_mapString map[string]*Listening

	OnAfterListeningCreateCallback OnAfterCreateInterface[Listening]
	OnAfterListeningUpdateCallback OnAfterUpdateInterface[Listening]
	OnAfterListeningDeleteCallback OnAfterDeleteInterface[Listening]
	OnAfterListeningReadCallback   OnAfterReadInterface[Listening]

	Lyrics           map[*Lyric]any
	Lyrics_mapString map[string]*Lyric

	OnAfterLyricCreateCallback OnAfterCreateInterface[Lyric]
	OnAfterLyricUpdateCallback OnAfterUpdateInterface[Lyric]
	OnAfterLyricDeleteCallback OnAfterDeleteInterface[Lyric]
	OnAfterLyricReadCallback   OnAfterReadInterface[Lyric]

	Lyric_fonts           map[*Lyric_font]any
	Lyric_fonts_mapString map[string]*Lyric_font

	OnAfterLyric_fontCreateCallback OnAfterCreateInterface[Lyric_font]
	OnAfterLyric_fontUpdateCallback OnAfterUpdateInterface[Lyric_font]
	OnAfterLyric_fontDeleteCallback OnAfterDeleteInterface[Lyric_font]
	OnAfterLyric_fontReadCallback   OnAfterReadInterface[Lyric_font]

	Lyric_languages           map[*Lyric_language]any
	Lyric_languages_mapString map[string]*Lyric_language

	OnAfterLyric_languageCreateCallback OnAfterCreateInterface[Lyric_language]
	OnAfterLyric_languageUpdateCallback OnAfterUpdateInterface[Lyric_language]
	OnAfterLyric_languageDeleteCallback OnAfterDeleteInterface[Lyric_language]
	OnAfterLyric_languageReadCallback   OnAfterReadInterface[Lyric_language]

	Measure_layouts           map[*Measure_layout]any
	Measure_layouts_mapString map[string]*Measure_layout

	OnAfterMeasure_layoutCreateCallback OnAfterCreateInterface[Measure_layout]
	OnAfterMeasure_layoutUpdateCallback OnAfterUpdateInterface[Measure_layout]
	OnAfterMeasure_layoutDeleteCallback OnAfterDeleteInterface[Measure_layout]
	OnAfterMeasure_layoutReadCallback   OnAfterReadInterface[Measure_layout]

	Measure_numberings           map[*Measure_numbering]any
	Measure_numberings_mapString map[string]*Measure_numbering

	OnAfterMeasure_numberingCreateCallback OnAfterCreateInterface[Measure_numbering]
	OnAfterMeasure_numberingUpdateCallback OnAfterUpdateInterface[Measure_numbering]
	OnAfterMeasure_numberingDeleteCallback OnAfterDeleteInterface[Measure_numbering]
	OnAfterMeasure_numberingReadCallback   OnAfterReadInterface[Measure_numbering]

	Measure_repeats           map[*Measure_repeat]any
	Measure_repeats_mapString map[string]*Measure_repeat

	OnAfterMeasure_repeatCreateCallback OnAfterCreateInterface[Measure_repeat]
	OnAfterMeasure_repeatUpdateCallback OnAfterUpdateInterface[Measure_repeat]
	OnAfterMeasure_repeatDeleteCallback OnAfterDeleteInterface[Measure_repeat]
	OnAfterMeasure_repeatReadCallback   OnAfterReadInterface[Measure_repeat]

	Measure_styles           map[*Measure_style]any
	Measure_styles_mapString map[string]*Measure_style

	OnAfterMeasure_styleCreateCallback OnAfterCreateInterface[Measure_style]
	OnAfterMeasure_styleUpdateCallback OnAfterUpdateInterface[Measure_style]
	OnAfterMeasure_styleDeleteCallback OnAfterDeleteInterface[Measure_style]
	OnAfterMeasure_styleReadCallback   OnAfterReadInterface[Measure_style]

	Membranes           map[*Membrane]any
	Membranes_mapString map[string]*Membrane

	OnAfterMembraneCreateCallback OnAfterCreateInterface[Membrane]
	OnAfterMembraneUpdateCallback OnAfterUpdateInterface[Membrane]
	OnAfterMembraneDeleteCallback OnAfterDeleteInterface[Membrane]
	OnAfterMembraneReadCallback   OnAfterReadInterface[Membrane]

	Metals           map[*Metal]any
	Metals_mapString map[string]*Metal

	OnAfterMetalCreateCallback OnAfterCreateInterface[Metal]
	OnAfterMetalUpdateCallback OnAfterUpdateInterface[Metal]
	OnAfterMetalDeleteCallback OnAfterDeleteInterface[Metal]
	OnAfterMetalReadCallback   OnAfterReadInterface[Metal]

	Metronomes           map[*Metronome]any
	Metronomes_mapString map[string]*Metronome

	OnAfterMetronomeCreateCallback OnAfterCreateInterface[Metronome]
	OnAfterMetronomeUpdateCallback OnAfterUpdateInterface[Metronome]
	OnAfterMetronomeDeleteCallback OnAfterDeleteInterface[Metronome]
	OnAfterMetronomeReadCallback   OnAfterReadInterface[Metronome]

	Metronome_beams           map[*Metronome_beam]any
	Metronome_beams_mapString map[string]*Metronome_beam

	OnAfterMetronome_beamCreateCallback OnAfterCreateInterface[Metronome_beam]
	OnAfterMetronome_beamUpdateCallback OnAfterUpdateInterface[Metronome_beam]
	OnAfterMetronome_beamDeleteCallback OnAfterDeleteInterface[Metronome_beam]
	OnAfterMetronome_beamReadCallback   OnAfterReadInterface[Metronome_beam]

	Metronome_notes           map[*Metronome_note]any
	Metronome_notes_mapString map[string]*Metronome_note

	// insertion point for slice of pointers maps
	Metronome_note_Metronome_dot_reverseMap  map[*Empty]*Metronome_note
	Metronome_note_Metronome_beam_reverseMap map[*Metronome_beam]*Metronome_note

	OnAfterMetronome_noteCreateCallback OnAfterCreateInterface[Metronome_note]
	OnAfterMetronome_noteUpdateCallback OnAfterUpdateInterface[Metronome_note]
	OnAfterMetronome_noteDeleteCallback OnAfterDeleteInterface[Metronome_note]
	OnAfterMetronome_noteReadCallback   OnAfterReadInterface[Metronome_note]

	Metronome_tieds           map[*Metronome_tied]any
	Metronome_tieds_mapString map[string]*Metronome_tied

	OnAfterMetronome_tiedCreateCallback OnAfterCreateInterface[Metronome_tied]
	OnAfterMetronome_tiedUpdateCallback OnAfterUpdateInterface[Metronome_tied]
	OnAfterMetronome_tiedDeleteCallback OnAfterDeleteInterface[Metronome_tied]
	OnAfterMetronome_tiedReadCallback   OnAfterReadInterface[Metronome_tied]

	Metronome_tuplets           map[*Metronome_tuplet]any
	Metronome_tuplets_mapString map[string]*Metronome_tuplet

	OnAfterMetronome_tupletCreateCallback OnAfterCreateInterface[Metronome_tuplet]
	OnAfterMetronome_tupletUpdateCallback OnAfterUpdateInterface[Metronome_tuplet]
	OnAfterMetronome_tupletDeleteCallback OnAfterDeleteInterface[Metronome_tuplet]
	OnAfterMetronome_tupletReadCallback   OnAfterReadInterface[Metronome_tuplet]

	Midi_devices           map[*Midi_device]any
	Midi_devices_mapString map[string]*Midi_device

	OnAfterMidi_deviceCreateCallback OnAfterCreateInterface[Midi_device]
	OnAfterMidi_deviceUpdateCallback OnAfterUpdateInterface[Midi_device]
	OnAfterMidi_deviceDeleteCallback OnAfterDeleteInterface[Midi_device]
	OnAfterMidi_deviceReadCallback   OnAfterReadInterface[Midi_device]

	Midi_instruments           map[*Midi_instrument]any
	Midi_instruments_mapString map[string]*Midi_instrument

	OnAfterMidi_instrumentCreateCallback OnAfterCreateInterface[Midi_instrument]
	OnAfterMidi_instrumentUpdateCallback OnAfterUpdateInterface[Midi_instrument]
	OnAfterMidi_instrumentDeleteCallback OnAfterDeleteInterface[Midi_instrument]
	OnAfterMidi_instrumentReadCallback   OnAfterReadInterface[Midi_instrument]

	Miscellaneouss           map[*Miscellaneous]any
	Miscellaneouss_mapString map[string]*Miscellaneous

	// insertion point for slice of pointers maps
	Miscellaneous_Miscellaneous_field_reverseMap map[*Miscellaneous_field]*Miscellaneous

	OnAfterMiscellaneousCreateCallback OnAfterCreateInterface[Miscellaneous]
	OnAfterMiscellaneousUpdateCallback OnAfterUpdateInterface[Miscellaneous]
	OnAfterMiscellaneousDeleteCallback OnAfterDeleteInterface[Miscellaneous]
	OnAfterMiscellaneousReadCallback   OnAfterReadInterface[Miscellaneous]

	Miscellaneous_fields           map[*Miscellaneous_field]any
	Miscellaneous_fields_mapString map[string]*Miscellaneous_field

	OnAfterMiscellaneous_fieldCreateCallback OnAfterCreateInterface[Miscellaneous_field]
	OnAfterMiscellaneous_fieldUpdateCallback OnAfterUpdateInterface[Miscellaneous_field]
	OnAfterMiscellaneous_fieldDeleteCallback OnAfterDeleteInterface[Miscellaneous_field]
	OnAfterMiscellaneous_fieldReadCallback   OnAfterReadInterface[Miscellaneous_field]

	Mordents           map[*Mordent]any
	Mordents_mapString map[string]*Mordent

	OnAfterMordentCreateCallback OnAfterCreateInterface[Mordent]
	OnAfterMordentUpdateCallback OnAfterUpdateInterface[Mordent]
	OnAfterMordentDeleteCallback OnAfterDeleteInterface[Mordent]
	OnAfterMordentReadCallback   OnAfterReadInterface[Mordent]

	Multiple_rests           map[*Multiple_rest]any
	Multiple_rests_mapString map[string]*Multiple_rest

	OnAfterMultiple_restCreateCallback OnAfterCreateInterface[Multiple_rest]
	OnAfterMultiple_restUpdateCallback OnAfterUpdateInterface[Multiple_rest]
	OnAfterMultiple_restDeleteCallback OnAfterDeleteInterface[Multiple_rest]
	OnAfterMultiple_restReadCallback   OnAfterReadInterface[Multiple_rest]

	Name_displays           map[*Name_display]any
	Name_displays_mapString map[string]*Name_display

	OnAfterName_displayCreateCallback OnAfterCreateInterface[Name_display]
	OnAfterName_displayUpdateCallback OnAfterUpdateInterface[Name_display]
	OnAfterName_displayDeleteCallback OnAfterDeleteInterface[Name_display]
	OnAfterName_displayReadCallback   OnAfterReadInterface[Name_display]

	Non_arpeggiates           map[*Non_arpeggiate]any
	Non_arpeggiates_mapString map[string]*Non_arpeggiate

	OnAfterNon_arpeggiateCreateCallback OnAfterCreateInterface[Non_arpeggiate]
	OnAfterNon_arpeggiateUpdateCallback OnAfterUpdateInterface[Non_arpeggiate]
	OnAfterNon_arpeggiateDeleteCallback OnAfterDeleteInterface[Non_arpeggiate]
	OnAfterNon_arpeggiateReadCallback   OnAfterReadInterface[Non_arpeggiate]

	Notationss           map[*Notations]any
	Notationss_mapString map[string]*Notations

	OnAfterNotationsCreateCallback OnAfterCreateInterface[Notations]
	OnAfterNotationsUpdateCallback OnAfterUpdateInterface[Notations]
	OnAfterNotationsDeleteCallback OnAfterDeleteInterface[Notations]
	OnAfterNotationsReadCallback   OnAfterReadInterface[Notations]

	Notes           map[*Note]any
	Notes_mapString map[string]*Note

	// insertion point for slice of pointers maps
	Note_Instrument_reverseMap map[*Instrument]*Note
	Note_Dot_reverseMap        map[*Empty_placement]*Note
	Note_Notations_reverseMap  map[*Notations]*Note
	Note_Lyric_reverseMap      map[*Lyric]*Note

	OnAfterNoteCreateCallback OnAfterCreateInterface[Note]
	OnAfterNoteUpdateCallback OnAfterUpdateInterface[Note]
	OnAfterNoteDeleteCallback OnAfterDeleteInterface[Note]
	OnAfterNoteReadCallback   OnAfterReadInterface[Note]

	Note_sizes           map[*Note_size]any
	Note_sizes_mapString map[string]*Note_size

	OnAfterNote_sizeCreateCallback OnAfterCreateInterface[Note_size]
	OnAfterNote_sizeUpdateCallback OnAfterUpdateInterface[Note_size]
	OnAfterNote_sizeDeleteCallback OnAfterDeleteInterface[Note_size]
	OnAfterNote_sizeReadCallback   OnAfterReadInterface[Note_size]

	Note_types           map[*Note_type]any
	Note_types_mapString map[string]*Note_type

	OnAfterNote_typeCreateCallback OnAfterCreateInterface[Note_type]
	OnAfterNote_typeUpdateCallback OnAfterUpdateInterface[Note_type]
	OnAfterNote_typeDeleteCallback OnAfterDeleteInterface[Note_type]
	OnAfterNote_typeReadCallback   OnAfterReadInterface[Note_type]

	Noteheads           map[*Notehead]any
	Noteheads_mapString map[string]*Notehead

	OnAfterNoteheadCreateCallback OnAfterCreateInterface[Notehead]
	OnAfterNoteheadUpdateCallback OnAfterUpdateInterface[Notehead]
	OnAfterNoteheadDeleteCallback OnAfterDeleteInterface[Notehead]
	OnAfterNoteheadReadCallback   OnAfterReadInterface[Notehead]

	Notehead_texts           map[*Notehead_text]any
	Notehead_texts_mapString map[string]*Notehead_text

	OnAfterNotehead_textCreateCallback OnAfterCreateInterface[Notehead_text]
	OnAfterNotehead_textUpdateCallback OnAfterUpdateInterface[Notehead_text]
	OnAfterNotehead_textDeleteCallback OnAfterDeleteInterface[Notehead_text]
	OnAfterNotehead_textReadCallback   OnAfterReadInterface[Notehead_text]

	Numerals           map[*Numeral]any
	Numerals_mapString map[string]*Numeral

	OnAfterNumeralCreateCallback OnAfterCreateInterface[Numeral]
	OnAfterNumeralUpdateCallback OnAfterUpdateInterface[Numeral]
	OnAfterNumeralDeleteCallback OnAfterDeleteInterface[Numeral]
	OnAfterNumeralReadCallback   OnAfterReadInterface[Numeral]

	Numeral_keys           map[*Numeral_key]any
	Numeral_keys_mapString map[string]*Numeral_key

	OnAfterNumeral_keyCreateCallback OnAfterCreateInterface[Numeral_key]
	OnAfterNumeral_keyUpdateCallback OnAfterUpdateInterface[Numeral_key]
	OnAfterNumeral_keyDeleteCallback OnAfterDeleteInterface[Numeral_key]
	OnAfterNumeral_keyReadCallback   OnAfterReadInterface[Numeral_key]

	Numeral_roots           map[*Numeral_root]any
	Numeral_roots_mapString map[string]*Numeral_root

	OnAfterNumeral_rootCreateCallback OnAfterCreateInterface[Numeral_root]
	OnAfterNumeral_rootUpdateCallback OnAfterUpdateInterface[Numeral_root]
	OnAfterNumeral_rootDeleteCallback OnAfterDeleteInterface[Numeral_root]
	OnAfterNumeral_rootReadCallback   OnAfterReadInterface[Numeral_root]

	Octave_shifts           map[*Octave_shift]any
	Octave_shifts_mapString map[string]*Octave_shift

	OnAfterOctave_shiftCreateCallback OnAfterCreateInterface[Octave_shift]
	OnAfterOctave_shiftUpdateCallback OnAfterUpdateInterface[Octave_shift]
	OnAfterOctave_shiftDeleteCallback OnAfterDeleteInterface[Octave_shift]
	OnAfterOctave_shiftReadCallback   OnAfterReadInterface[Octave_shift]

	Offsets           map[*Offset]any
	Offsets_mapString map[string]*Offset

	OnAfterOffsetCreateCallback OnAfterCreateInterface[Offset]
	OnAfterOffsetUpdateCallback OnAfterUpdateInterface[Offset]
	OnAfterOffsetDeleteCallback OnAfterDeleteInterface[Offset]
	OnAfterOffsetReadCallback   OnAfterReadInterface[Offset]

	Opuss           map[*Opus]any
	Opuss_mapString map[string]*Opus

	OnAfterOpusCreateCallback OnAfterCreateInterface[Opus]
	OnAfterOpusUpdateCallback OnAfterUpdateInterface[Opus]
	OnAfterOpusDeleteCallback OnAfterDeleteInterface[Opus]
	OnAfterOpusReadCallback   OnAfterReadInterface[Opus]

	Ornamentss           map[*Ornaments]any
	Ornamentss_mapString map[string]*Ornaments

	// insertion point for slice of pointers maps
	Ornaments_Accidental_mark_reverseMap map[*Accidental_mark]*Ornaments

	OnAfterOrnamentsCreateCallback OnAfterCreateInterface[Ornaments]
	OnAfterOrnamentsUpdateCallback OnAfterUpdateInterface[Ornaments]
	OnAfterOrnamentsDeleteCallback OnAfterDeleteInterface[Ornaments]
	OnAfterOrnamentsReadCallback   OnAfterReadInterface[Ornaments]

	Other_appearances           map[*Other_appearance]any
	Other_appearances_mapString map[string]*Other_appearance

	OnAfterOther_appearanceCreateCallback OnAfterCreateInterface[Other_appearance]
	OnAfterOther_appearanceUpdateCallback OnAfterUpdateInterface[Other_appearance]
	OnAfterOther_appearanceDeleteCallback OnAfterDeleteInterface[Other_appearance]
	OnAfterOther_appearanceReadCallback   OnAfterReadInterface[Other_appearance]

	Other_listenings           map[*Other_listening]any
	Other_listenings_mapString map[string]*Other_listening

	OnAfterOther_listeningCreateCallback OnAfterCreateInterface[Other_listening]
	OnAfterOther_listeningUpdateCallback OnAfterUpdateInterface[Other_listening]
	OnAfterOther_listeningDeleteCallback OnAfterDeleteInterface[Other_listening]
	OnAfterOther_listeningReadCallback   OnAfterReadInterface[Other_listening]

	Other_notations           map[*Other_notation]any
	Other_notations_mapString map[string]*Other_notation

	OnAfterOther_notationCreateCallback OnAfterCreateInterface[Other_notation]
	OnAfterOther_notationUpdateCallback OnAfterUpdateInterface[Other_notation]
	OnAfterOther_notationDeleteCallback OnAfterDeleteInterface[Other_notation]
	OnAfterOther_notationReadCallback   OnAfterReadInterface[Other_notation]

	Other_plays           map[*Other_play]any
	Other_plays_mapString map[string]*Other_play

	OnAfterOther_playCreateCallback OnAfterCreateInterface[Other_play]
	OnAfterOther_playUpdateCallback OnAfterUpdateInterface[Other_play]
	OnAfterOther_playDeleteCallback OnAfterDeleteInterface[Other_play]
	OnAfterOther_playReadCallback   OnAfterReadInterface[Other_play]

	Page_layouts           map[*Page_layout]any
	Page_layouts_mapString map[string]*Page_layout

	OnAfterPage_layoutCreateCallback OnAfterCreateInterface[Page_layout]
	OnAfterPage_layoutUpdateCallback OnAfterUpdateInterface[Page_layout]
	OnAfterPage_layoutDeleteCallback OnAfterDeleteInterface[Page_layout]
	OnAfterPage_layoutReadCallback   OnAfterReadInterface[Page_layout]

	Page_marginss           map[*Page_margins]any
	Page_marginss_mapString map[string]*Page_margins

	OnAfterPage_marginsCreateCallback OnAfterCreateInterface[Page_margins]
	OnAfterPage_marginsUpdateCallback OnAfterUpdateInterface[Page_margins]
	OnAfterPage_marginsDeleteCallback OnAfterDeleteInterface[Page_margins]
	OnAfterPage_marginsReadCallback   OnAfterReadInterface[Page_margins]

	Part_clefs           map[*Part_clef]any
	Part_clefs_mapString map[string]*Part_clef

	OnAfterPart_clefCreateCallback OnAfterCreateInterface[Part_clef]
	OnAfterPart_clefUpdateCallback OnAfterUpdateInterface[Part_clef]
	OnAfterPart_clefDeleteCallback OnAfterDeleteInterface[Part_clef]
	OnAfterPart_clefReadCallback   OnAfterReadInterface[Part_clef]

	Part_groups           map[*Part_group]any
	Part_groups_mapString map[string]*Part_group

	OnAfterPart_groupCreateCallback OnAfterCreateInterface[Part_group]
	OnAfterPart_groupUpdateCallback OnAfterUpdateInterface[Part_group]
	OnAfterPart_groupDeleteCallback OnAfterDeleteInterface[Part_group]
	OnAfterPart_groupReadCallback   OnAfterReadInterface[Part_group]

	Part_links           map[*Part_link]any
	Part_links_mapString map[string]*Part_link

	// insertion point for slice of pointers maps
	Part_link_Instrument_link_reverseMap map[*Instrument_link]*Part_link

	OnAfterPart_linkCreateCallback OnAfterCreateInterface[Part_link]
	OnAfterPart_linkUpdateCallback OnAfterUpdateInterface[Part_link]
	OnAfterPart_linkDeleteCallback OnAfterDeleteInterface[Part_link]
	OnAfterPart_linkReadCallback   OnAfterReadInterface[Part_link]

	Part_lists           map[*Part_list]any
	Part_lists_mapString map[string]*Part_list

	OnAfterPart_listCreateCallback OnAfterCreateInterface[Part_list]
	OnAfterPart_listUpdateCallback OnAfterUpdateInterface[Part_list]
	OnAfterPart_listDeleteCallback OnAfterDeleteInterface[Part_list]
	OnAfterPart_listReadCallback   OnAfterReadInterface[Part_list]

	Part_symbols           map[*Part_symbol]any
	Part_symbols_mapString map[string]*Part_symbol

	OnAfterPart_symbolCreateCallback OnAfterCreateInterface[Part_symbol]
	OnAfterPart_symbolUpdateCallback OnAfterUpdateInterface[Part_symbol]
	OnAfterPart_symbolDeleteCallback OnAfterDeleteInterface[Part_symbol]
	OnAfterPart_symbolReadCallback   OnAfterReadInterface[Part_symbol]

	Part_transposes           map[*Part_transpose]any
	Part_transposes_mapString map[string]*Part_transpose

	OnAfterPart_transposeCreateCallback OnAfterCreateInterface[Part_transpose]
	OnAfterPart_transposeUpdateCallback OnAfterUpdateInterface[Part_transpose]
	OnAfterPart_transposeDeleteCallback OnAfterDeleteInterface[Part_transpose]
	OnAfterPart_transposeReadCallback   OnAfterReadInterface[Part_transpose]

	Pedals           map[*Pedal]any
	Pedals_mapString map[string]*Pedal

	OnAfterPedalCreateCallback OnAfterCreateInterface[Pedal]
	OnAfterPedalUpdateCallback OnAfterUpdateInterface[Pedal]
	OnAfterPedalDeleteCallback OnAfterDeleteInterface[Pedal]
	OnAfterPedalReadCallback   OnAfterReadInterface[Pedal]

	Pedal_tunings           map[*Pedal_tuning]any
	Pedal_tunings_mapString map[string]*Pedal_tuning

	OnAfterPedal_tuningCreateCallback OnAfterCreateInterface[Pedal_tuning]
	OnAfterPedal_tuningUpdateCallback OnAfterUpdateInterface[Pedal_tuning]
	OnAfterPedal_tuningDeleteCallback OnAfterDeleteInterface[Pedal_tuning]
	OnAfterPedal_tuningReadCallback   OnAfterReadInterface[Pedal_tuning]

	Percussions           map[*Percussion]any
	Percussions_mapString map[string]*Percussion

	OnAfterPercussionCreateCallback OnAfterCreateInterface[Percussion]
	OnAfterPercussionUpdateCallback OnAfterUpdateInterface[Percussion]
	OnAfterPercussionDeleteCallback OnAfterDeleteInterface[Percussion]
	OnAfterPercussionReadCallback   OnAfterReadInterface[Percussion]

	Pitchs           map[*Pitch]any
	Pitchs_mapString map[string]*Pitch

	OnAfterPitchCreateCallback OnAfterCreateInterface[Pitch]
	OnAfterPitchUpdateCallback OnAfterUpdateInterface[Pitch]
	OnAfterPitchDeleteCallback OnAfterDeleteInterface[Pitch]
	OnAfterPitchReadCallback   OnAfterReadInterface[Pitch]

	Pitcheds           map[*Pitched]any
	Pitcheds_mapString map[string]*Pitched

	OnAfterPitchedCreateCallback OnAfterCreateInterface[Pitched]
	OnAfterPitchedUpdateCallback OnAfterUpdateInterface[Pitched]
	OnAfterPitchedDeleteCallback OnAfterDeleteInterface[Pitched]
	OnAfterPitchedReadCallback   OnAfterReadInterface[Pitched]

	Plays           map[*Play]any
	Plays_mapString map[string]*Play

	OnAfterPlayCreateCallback OnAfterCreateInterface[Play]
	OnAfterPlayUpdateCallback OnAfterUpdateInterface[Play]
	OnAfterPlayDeleteCallback OnAfterDeleteInterface[Play]
	OnAfterPlayReadCallback   OnAfterReadInterface[Play]

	Players           map[*Player]any
	Players_mapString map[string]*Player

	OnAfterPlayerCreateCallback OnAfterCreateInterface[Player]
	OnAfterPlayerUpdateCallback OnAfterUpdateInterface[Player]
	OnAfterPlayerDeleteCallback OnAfterDeleteInterface[Player]
	OnAfterPlayerReadCallback   OnAfterReadInterface[Player]

	Principal_voices           map[*Principal_voice]any
	Principal_voices_mapString map[string]*Principal_voice

	OnAfterPrincipal_voiceCreateCallback OnAfterCreateInterface[Principal_voice]
	OnAfterPrincipal_voiceUpdateCallback OnAfterUpdateInterface[Principal_voice]
	OnAfterPrincipal_voiceDeleteCallback OnAfterDeleteInterface[Principal_voice]
	OnAfterPrincipal_voiceReadCallback   OnAfterReadInterface[Principal_voice]

	Prints           map[*Print]any
	Prints_mapString map[string]*Print

	OnAfterPrintCreateCallback OnAfterCreateInterface[Print]
	OnAfterPrintUpdateCallback OnAfterUpdateInterface[Print]
	OnAfterPrintDeleteCallback OnAfterDeleteInterface[Print]
	OnAfterPrintReadCallback   OnAfterReadInterface[Print]

	Releases           map[*Release]any
	Releases_mapString map[string]*Release

	OnAfterReleaseCreateCallback OnAfterCreateInterface[Release]
	OnAfterReleaseUpdateCallback OnAfterUpdateInterface[Release]
	OnAfterReleaseDeleteCallback OnAfterDeleteInterface[Release]
	OnAfterReleaseReadCallback   OnAfterReadInterface[Release]

	Repeats           map[*Repeat]any
	Repeats_mapString map[string]*Repeat

	OnAfterRepeatCreateCallback OnAfterCreateInterface[Repeat]
	OnAfterRepeatUpdateCallback OnAfterUpdateInterface[Repeat]
	OnAfterRepeatDeleteCallback OnAfterDeleteInterface[Repeat]
	OnAfterRepeatReadCallback   OnAfterReadInterface[Repeat]

	Rests           map[*Rest]any
	Rests_mapString map[string]*Rest

	OnAfterRestCreateCallback OnAfterCreateInterface[Rest]
	OnAfterRestUpdateCallback OnAfterUpdateInterface[Rest]
	OnAfterRestDeleteCallback OnAfterDeleteInterface[Rest]
	OnAfterRestReadCallback   OnAfterReadInterface[Rest]

	Roots           map[*Root]any
	Roots_mapString map[string]*Root

	OnAfterRootCreateCallback OnAfterCreateInterface[Root]
	OnAfterRootUpdateCallback OnAfterUpdateInterface[Root]
	OnAfterRootDeleteCallback OnAfterDeleteInterface[Root]
	OnAfterRootReadCallback   OnAfterReadInterface[Root]

	Root_steps           map[*Root_step]any
	Root_steps_mapString map[string]*Root_step

	OnAfterRoot_stepCreateCallback OnAfterCreateInterface[Root_step]
	OnAfterRoot_stepUpdateCallback OnAfterUpdateInterface[Root_step]
	OnAfterRoot_stepDeleteCallback OnAfterDeleteInterface[Root_step]
	OnAfterRoot_stepReadCallback   OnAfterReadInterface[Root_step]

	Scalings           map[*Scaling]any
	Scalings_mapString map[string]*Scaling

	OnAfterScalingCreateCallback OnAfterCreateInterface[Scaling]
	OnAfterScalingUpdateCallback OnAfterUpdateInterface[Scaling]
	OnAfterScalingDeleteCallback OnAfterDeleteInterface[Scaling]
	OnAfterScalingReadCallback   OnAfterReadInterface[Scaling]

	Scordaturas           map[*Scordatura]any
	Scordaturas_mapString map[string]*Scordatura

	// insertion point for slice of pointers maps
	Scordatura_Accord_reverseMap map[*Accord]*Scordatura

	OnAfterScordaturaCreateCallback OnAfterCreateInterface[Scordatura]
	OnAfterScordaturaUpdateCallback OnAfterUpdateInterface[Scordatura]
	OnAfterScordaturaDeleteCallback OnAfterDeleteInterface[Scordatura]
	OnAfterScordaturaReadCallback   OnAfterReadInterface[Scordatura]

	Score_instruments           map[*Score_instrument]any
	Score_instruments_mapString map[string]*Score_instrument

	OnAfterScore_instrumentCreateCallback OnAfterCreateInterface[Score_instrument]
	OnAfterScore_instrumentUpdateCallback OnAfterUpdateInterface[Score_instrument]
	OnAfterScore_instrumentDeleteCallback OnAfterDeleteInterface[Score_instrument]
	OnAfterScore_instrumentReadCallback   OnAfterReadInterface[Score_instrument]

	Score_parts           map[*Score_part]any
	Score_parts_mapString map[string]*Score_part

	// insertion point for slice of pointers maps
	Score_part_Part_link_reverseMap        map[*Part_link]*Score_part
	Score_part_Score_instrument_reverseMap map[*Score_instrument]*Score_part
	Score_part_Player_reverseMap           map[*Player]*Score_part

	OnAfterScore_partCreateCallback OnAfterCreateInterface[Score_part]
	OnAfterScore_partUpdateCallback OnAfterUpdateInterface[Score_part]
	OnAfterScore_partDeleteCallback OnAfterDeleteInterface[Score_part]
	OnAfterScore_partReadCallback   OnAfterReadInterface[Score_part]

	Score_partwises           map[*Score_partwise]any
	Score_partwises_mapString map[string]*Score_partwise

	OnAfterScore_partwiseCreateCallback OnAfterCreateInterface[Score_partwise]
	OnAfterScore_partwiseUpdateCallback OnAfterUpdateInterface[Score_partwise]
	OnAfterScore_partwiseDeleteCallback OnAfterDeleteInterface[Score_partwise]
	OnAfterScore_partwiseReadCallback   OnAfterReadInterface[Score_partwise]

	Score_timewises           map[*Score_timewise]any
	Score_timewises_mapString map[string]*Score_timewise

	OnAfterScore_timewiseCreateCallback OnAfterCreateInterface[Score_timewise]
	OnAfterScore_timewiseUpdateCallback OnAfterUpdateInterface[Score_timewise]
	OnAfterScore_timewiseDeleteCallback OnAfterDeleteInterface[Score_timewise]
	OnAfterScore_timewiseReadCallback   OnAfterReadInterface[Score_timewise]

	Segnos           map[*Segno]any
	Segnos_mapString map[string]*Segno

	OnAfterSegnoCreateCallback OnAfterCreateInterface[Segno]
	OnAfterSegnoUpdateCallback OnAfterUpdateInterface[Segno]
	OnAfterSegnoDeleteCallback OnAfterDeleteInterface[Segno]
	OnAfterSegnoReadCallback   OnAfterReadInterface[Segno]

	Slashs           map[*Slash]any
	Slashs_mapString map[string]*Slash

	OnAfterSlashCreateCallback OnAfterCreateInterface[Slash]
	OnAfterSlashUpdateCallback OnAfterUpdateInterface[Slash]
	OnAfterSlashDeleteCallback OnAfterDeleteInterface[Slash]
	OnAfterSlashReadCallback   OnAfterReadInterface[Slash]

	Slides           map[*Slide]any
	Slides_mapString map[string]*Slide

	OnAfterSlideCreateCallback OnAfterCreateInterface[Slide]
	OnAfterSlideUpdateCallback OnAfterUpdateInterface[Slide]
	OnAfterSlideDeleteCallback OnAfterDeleteInterface[Slide]
	OnAfterSlideReadCallback   OnAfterReadInterface[Slide]

	Slurs           map[*Slur]any
	Slurs_mapString map[string]*Slur

	OnAfterSlurCreateCallback OnAfterCreateInterface[Slur]
	OnAfterSlurUpdateCallback OnAfterUpdateInterface[Slur]
	OnAfterSlurDeleteCallback OnAfterDeleteInterface[Slur]
	OnAfterSlurReadCallback   OnAfterReadInterface[Slur]

	Sounds           map[*Sound]any
	Sounds_mapString map[string]*Sound

	OnAfterSoundCreateCallback OnAfterCreateInterface[Sound]
	OnAfterSoundUpdateCallback OnAfterUpdateInterface[Sound]
	OnAfterSoundDeleteCallback OnAfterDeleteInterface[Sound]
	OnAfterSoundReadCallback   OnAfterReadInterface[Sound]

	Staff_detailss           map[*Staff_details]any
	Staff_detailss_mapString map[string]*Staff_details

	// insertion point for slice of pointers maps
	Staff_details_Staff_tuning_reverseMap map[*Staff_tuning]*Staff_details

	OnAfterStaff_detailsCreateCallback OnAfterCreateInterface[Staff_details]
	OnAfterStaff_detailsUpdateCallback OnAfterUpdateInterface[Staff_details]
	OnAfterStaff_detailsDeleteCallback OnAfterDeleteInterface[Staff_details]
	OnAfterStaff_detailsReadCallback   OnAfterReadInterface[Staff_details]

	Staff_divides           map[*Staff_divide]any
	Staff_divides_mapString map[string]*Staff_divide

	OnAfterStaff_divideCreateCallback OnAfterCreateInterface[Staff_divide]
	OnAfterStaff_divideUpdateCallback OnAfterUpdateInterface[Staff_divide]
	OnAfterStaff_divideDeleteCallback OnAfterDeleteInterface[Staff_divide]
	OnAfterStaff_divideReadCallback   OnAfterReadInterface[Staff_divide]

	Staff_layouts           map[*Staff_layout]any
	Staff_layouts_mapString map[string]*Staff_layout

	OnAfterStaff_layoutCreateCallback OnAfterCreateInterface[Staff_layout]
	OnAfterStaff_layoutUpdateCallback OnAfterUpdateInterface[Staff_layout]
	OnAfterStaff_layoutDeleteCallback OnAfterDeleteInterface[Staff_layout]
	OnAfterStaff_layoutReadCallback   OnAfterReadInterface[Staff_layout]

	Staff_sizes           map[*Staff_size]any
	Staff_sizes_mapString map[string]*Staff_size

	OnAfterStaff_sizeCreateCallback OnAfterCreateInterface[Staff_size]
	OnAfterStaff_sizeUpdateCallback OnAfterUpdateInterface[Staff_size]
	OnAfterStaff_sizeDeleteCallback OnAfterDeleteInterface[Staff_size]
	OnAfterStaff_sizeReadCallback   OnAfterReadInterface[Staff_size]

	Staff_tunings           map[*Staff_tuning]any
	Staff_tunings_mapString map[string]*Staff_tuning

	OnAfterStaff_tuningCreateCallback OnAfterCreateInterface[Staff_tuning]
	OnAfterStaff_tuningUpdateCallback OnAfterUpdateInterface[Staff_tuning]
	OnAfterStaff_tuningDeleteCallback OnAfterDeleteInterface[Staff_tuning]
	OnAfterStaff_tuningReadCallback   OnAfterReadInterface[Staff_tuning]

	Stems           map[*Stem]any
	Stems_mapString map[string]*Stem

	OnAfterStemCreateCallback OnAfterCreateInterface[Stem]
	OnAfterStemUpdateCallback OnAfterUpdateInterface[Stem]
	OnAfterStemDeleteCallback OnAfterDeleteInterface[Stem]
	OnAfterStemReadCallback   OnAfterReadInterface[Stem]

	Sticks           map[*Stick]any
	Sticks_mapString map[string]*Stick

	OnAfterStickCreateCallback OnAfterCreateInterface[Stick]
	OnAfterStickUpdateCallback OnAfterUpdateInterface[Stick]
	OnAfterStickDeleteCallback OnAfterDeleteInterface[Stick]
	OnAfterStickReadCallback   OnAfterReadInterface[Stick]

	String_mutes           map[*String_mute]any
	String_mutes_mapString map[string]*String_mute

	OnAfterString_muteCreateCallback OnAfterCreateInterface[String_mute]
	OnAfterString_muteUpdateCallback OnAfterUpdateInterface[String_mute]
	OnAfterString_muteDeleteCallback OnAfterDeleteInterface[String_mute]
	OnAfterString_muteReadCallback   OnAfterReadInterface[String_mute]

	Strong_accents           map[*Strong_accent]any
	Strong_accents_mapString map[string]*Strong_accent

	OnAfterStrong_accentCreateCallback OnAfterCreateInterface[Strong_accent]
	OnAfterStrong_accentUpdateCallback OnAfterUpdateInterface[Strong_accent]
	OnAfterStrong_accentDeleteCallback OnAfterDeleteInterface[Strong_accent]
	OnAfterStrong_accentReadCallback   OnAfterReadInterface[Strong_accent]

	Supportss           map[*Supports]any
	Supportss_mapString map[string]*Supports

	OnAfterSupportsCreateCallback OnAfterCreateInterface[Supports]
	OnAfterSupportsUpdateCallback OnAfterUpdateInterface[Supports]
	OnAfterSupportsDeleteCallback OnAfterDeleteInterface[Supports]
	OnAfterSupportsReadCallback   OnAfterReadInterface[Supports]

	Swings           map[*Swing]any
	Swings_mapString map[string]*Swing

	OnAfterSwingCreateCallback OnAfterCreateInterface[Swing]
	OnAfterSwingUpdateCallback OnAfterUpdateInterface[Swing]
	OnAfterSwingDeleteCallback OnAfterDeleteInterface[Swing]
	OnAfterSwingReadCallback   OnAfterReadInterface[Swing]

	Syncs           map[*Sync]any
	Syncs_mapString map[string]*Sync

	OnAfterSyncCreateCallback OnAfterCreateInterface[Sync]
	OnAfterSyncUpdateCallback OnAfterUpdateInterface[Sync]
	OnAfterSyncDeleteCallback OnAfterDeleteInterface[Sync]
	OnAfterSyncReadCallback   OnAfterReadInterface[Sync]

	System_dividerss           map[*System_dividers]any
	System_dividerss_mapString map[string]*System_dividers

	OnAfterSystem_dividersCreateCallback OnAfterCreateInterface[System_dividers]
	OnAfterSystem_dividersUpdateCallback OnAfterUpdateInterface[System_dividers]
	OnAfterSystem_dividersDeleteCallback OnAfterDeleteInterface[System_dividers]
	OnAfterSystem_dividersReadCallback   OnAfterReadInterface[System_dividers]

	System_layouts           map[*System_layout]any
	System_layouts_mapString map[string]*System_layout

	OnAfterSystem_layoutCreateCallback OnAfterCreateInterface[System_layout]
	OnAfterSystem_layoutUpdateCallback OnAfterUpdateInterface[System_layout]
	OnAfterSystem_layoutDeleteCallback OnAfterDeleteInterface[System_layout]
	OnAfterSystem_layoutReadCallback   OnAfterReadInterface[System_layout]

	System_marginss           map[*System_margins]any
	System_marginss_mapString map[string]*System_margins

	OnAfterSystem_marginsCreateCallback OnAfterCreateInterface[System_margins]
	OnAfterSystem_marginsUpdateCallback OnAfterUpdateInterface[System_margins]
	OnAfterSystem_marginsDeleteCallback OnAfterDeleteInterface[System_margins]
	OnAfterSystem_marginsReadCallback   OnAfterReadInterface[System_margins]

	Taps           map[*Tap]any
	Taps_mapString map[string]*Tap

	OnAfterTapCreateCallback OnAfterCreateInterface[Tap]
	OnAfterTapUpdateCallback OnAfterUpdateInterface[Tap]
	OnAfterTapDeleteCallback OnAfterDeleteInterface[Tap]
	OnAfterTapReadCallback   OnAfterReadInterface[Tap]

	Technicals           map[*Technical]any
	Technicals_mapString map[string]*Technical

	OnAfterTechnicalCreateCallback OnAfterCreateInterface[Technical]
	OnAfterTechnicalUpdateCallback OnAfterUpdateInterface[Technical]
	OnAfterTechnicalDeleteCallback OnAfterDeleteInterface[Technical]
	OnAfterTechnicalReadCallback   OnAfterReadInterface[Technical]

	Text_element_datas           map[*Text_element_data]any
	Text_element_datas_mapString map[string]*Text_element_data

	OnAfterText_element_dataCreateCallback OnAfterCreateInterface[Text_element_data]
	OnAfterText_element_dataUpdateCallback OnAfterUpdateInterface[Text_element_data]
	OnAfterText_element_dataDeleteCallback OnAfterDeleteInterface[Text_element_data]
	OnAfterText_element_dataReadCallback   OnAfterReadInterface[Text_element_data]

	Ties           map[*Tie]any
	Ties_mapString map[string]*Tie

	OnAfterTieCreateCallback OnAfterCreateInterface[Tie]
	OnAfterTieUpdateCallback OnAfterUpdateInterface[Tie]
	OnAfterTieDeleteCallback OnAfterDeleteInterface[Tie]
	OnAfterTieReadCallback   OnAfterReadInterface[Tie]

	Tieds           map[*Tied]any
	Tieds_mapString map[string]*Tied

	OnAfterTiedCreateCallback OnAfterCreateInterface[Tied]
	OnAfterTiedUpdateCallback OnAfterUpdateInterface[Tied]
	OnAfterTiedDeleteCallback OnAfterDeleteInterface[Tied]
	OnAfterTiedReadCallback   OnAfterReadInterface[Tied]

	Times           map[*Time]any
	Times_mapString map[string]*Time

	OnAfterTimeCreateCallback OnAfterCreateInterface[Time]
	OnAfterTimeUpdateCallback OnAfterUpdateInterface[Time]
	OnAfterTimeDeleteCallback OnAfterDeleteInterface[Time]
	OnAfterTimeReadCallback   OnAfterReadInterface[Time]

	Time_modifications           map[*Time_modification]any
	Time_modifications_mapString map[string]*Time_modification

	OnAfterTime_modificationCreateCallback OnAfterCreateInterface[Time_modification]
	OnAfterTime_modificationUpdateCallback OnAfterUpdateInterface[Time_modification]
	OnAfterTime_modificationDeleteCallback OnAfterDeleteInterface[Time_modification]
	OnAfterTime_modificationReadCallback   OnAfterReadInterface[Time_modification]

	Timpanis           map[*Timpani]any
	Timpanis_mapString map[string]*Timpani

	OnAfterTimpaniCreateCallback OnAfterCreateInterface[Timpani]
	OnAfterTimpaniUpdateCallback OnAfterUpdateInterface[Timpani]
	OnAfterTimpaniDeleteCallback OnAfterDeleteInterface[Timpani]
	OnAfterTimpaniReadCallback   OnAfterReadInterface[Timpani]

	Transposes           map[*Transpose]any
	Transposes_mapString map[string]*Transpose

	OnAfterTransposeCreateCallback OnAfterCreateInterface[Transpose]
	OnAfterTransposeUpdateCallback OnAfterUpdateInterface[Transpose]
	OnAfterTransposeDeleteCallback OnAfterDeleteInterface[Transpose]
	OnAfterTransposeReadCallback   OnAfterReadInterface[Transpose]

	Tremolos           map[*Tremolo]any
	Tremolos_mapString map[string]*Tremolo

	OnAfterTremoloCreateCallback OnAfterCreateInterface[Tremolo]
	OnAfterTremoloUpdateCallback OnAfterUpdateInterface[Tremolo]
	OnAfterTremoloDeleteCallback OnAfterDeleteInterface[Tremolo]
	OnAfterTremoloReadCallback   OnAfterReadInterface[Tremolo]

	Tuplets           map[*Tuplet]any
	Tuplets_mapString map[string]*Tuplet

	OnAfterTupletCreateCallback OnAfterCreateInterface[Tuplet]
	OnAfterTupletUpdateCallback OnAfterUpdateInterface[Tuplet]
	OnAfterTupletDeleteCallback OnAfterDeleteInterface[Tuplet]
	OnAfterTupletReadCallback   OnAfterReadInterface[Tuplet]

	Tuplet_dots           map[*Tuplet_dot]any
	Tuplet_dots_mapString map[string]*Tuplet_dot

	OnAfterTuplet_dotCreateCallback OnAfterCreateInterface[Tuplet_dot]
	OnAfterTuplet_dotUpdateCallback OnAfterUpdateInterface[Tuplet_dot]
	OnAfterTuplet_dotDeleteCallback OnAfterDeleteInterface[Tuplet_dot]
	OnAfterTuplet_dotReadCallback   OnAfterReadInterface[Tuplet_dot]

	Tuplet_numbers           map[*Tuplet_number]any
	Tuplet_numbers_mapString map[string]*Tuplet_number

	OnAfterTuplet_numberCreateCallback OnAfterCreateInterface[Tuplet_number]
	OnAfterTuplet_numberUpdateCallback OnAfterUpdateInterface[Tuplet_number]
	OnAfterTuplet_numberDeleteCallback OnAfterDeleteInterface[Tuplet_number]
	OnAfterTuplet_numberReadCallback   OnAfterReadInterface[Tuplet_number]

	Tuplet_portions           map[*Tuplet_portion]any
	Tuplet_portions_mapString map[string]*Tuplet_portion

	// insertion point for slice of pointers maps
	Tuplet_portion_Tuplet_dot_reverseMap map[*Tuplet_dot]*Tuplet_portion

	OnAfterTuplet_portionCreateCallback OnAfterCreateInterface[Tuplet_portion]
	OnAfterTuplet_portionUpdateCallback OnAfterUpdateInterface[Tuplet_portion]
	OnAfterTuplet_portionDeleteCallback OnAfterDeleteInterface[Tuplet_portion]
	OnAfterTuplet_portionReadCallback   OnAfterReadInterface[Tuplet_portion]

	Tuplet_types           map[*Tuplet_type]any
	Tuplet_types_mapString map[string]*Tuplet_type

	OnAfterTuplet_typeCreateCallback OnAfterCreateInterface[Tuplet_type]
	OnAfterTuplet_typeUpdateCallback OnAfterUpdateInterface[Tuplet_type]
	OnAfterTuplet_typeDeleteCallback OnAfterDeleteInterface[Tuplet_type]
	OnAfterTuplet_typeReadCallback   OnAfterReadInterface[Tuplet_type]

	Typed_texts           map[*Typed_text]any
	Typed_texts_mapString map[string]*Typed_text

	OnAfterTyped_textCreateCallback OnAfterCreateInterface[Typed_text]
	OnAfterTyped_textUpdateCallback OnAfterUpdateInterface[Typed_text]
	OnAfterTyped_textDeleteCallback OnAfterDeleteInterface[Typed_text]
	OnAfterTyped_textReadCallback   OnAfterReadInterface[Typed_text]

	Unpitcheds           map[*Unpitched]any
	Unpitcheds_mapString map[string]*Unpitched

	OnAfterUnpitchedCreateCallback OnAfterCreateInterface[Unpitched]
	OnAfterUnpitchedUpdateCallback OnAfterUpdateInterface[Unpitched]
	OnAfterUnpitchedDeleteCallback OnAfterDeleteInterface[Unpitched]
	OnAfterUnpitchedReadCallback   OnAfterReadInterface[Unpitched]

	Virtual_instruments           map[*Virtual_instrument]any
	Virtual_instruments_mapString map[string]*Virtual_instrument

	OnAfterVirtual_instrumentCreateCallback OnAfterCreateInterface[Virtual_instrument]
	OnAfterVirtual_instrumentUpdateCallback OnAfterUpdateInterface[Virtual_instrument]
	OnAfterVirtual_instrumentDeleteCallback OnAfterDeleteInterface[Virtual_instrument]
	OnAfterVirtual_instrumentReadCallback   OnAfterReadInterface[Virtual_instrument]

	Waits           map[*Wait]any
	Waits_mapString map[string]*Wait

	OnAfterWaitCreateCallback OnAfterCreateInterface[Wait]
	OnAfterWaitUpdateCallback OnAfterUpdateInterface[Wait]
	OnAfterWaitDeleteCallback OnAfterDeleteInterface[Wait]
	OnAfterWaitReadCallback   OnAfterReadInterface[Wait]

	Wavy_lines           map[*Wavy_line]any
	Wavy_lines_mapString map[string]*Wavy_line

	OnAfterWavy_lineCreateCallback OnAfterCreateInterface[Wavy_line]
	OnAfterWavy_lineUpdateCallback OnAfterUpdateInterface[Wavy_line]
	OnAfterWavy_lineDeleteCallback OnAfterDeleteInterface[Wavy_line]
	OnAfterWavy_lineReadCallback   OnAfterReadInterface[Wavy_line]

	Wedges           map[*Wedge]any
	Wedges_mapString map[string]*Wedge

	OnAfterWedgeCreateCallback OnAfterCreateInterface[Wedge]
	OnAfterWedgeUpdateCallback OnAfterUpdateInterface[Wedge]
	OnAfterWedgeDeleteCallback OnAfterDeleteInterface[Wedge]
	OnAfterWedgeReadCallback   OnAfterReadInterface[Wedge]

	Woods           map[*Wood]any
	Woods_mapString map[string]*Wood

	OnAfterWoodCreateCallback OnAfterCreateInterface[Wood]
	OnAfterWoodUpdateCallback OnAfterUpdateInterface[Wood]
	OnAfterWoodDeleteCallback OnAfterDeleteInterface[Wood]
	OnAfterWoodReadCallback   OnAfterReadInterface[Wood]

	Works           map[*Work]any
	Works_mapString map[string]*Work

	OnAfterWorkCreateCallback OnAfterCreateInterface[Work]
	OnAfterWorkUpdateCallback OnAfterUpdateInterface[Work]
	OnAfterWorkDeleteCallback OnAfterDeleteInterface[Work]
	OnAfterWorkReadCallback   OnAfterReadInterface[Work]

	AllModelsStructCreateCallback AllModelsStructCreateInterface

	AllModelsStructDeleteCallback AllModelsStructDeleteInterface

	BackRepo BackRepoInterface

	// if set will be called before each commit to the back repo
	OnInitCommitCallback          OnInitCommitInterface
	OnInitCommitFromFrontCallback OnInitCommitInterface
	OnInitCommitFromBackCallback  OnInitCommitInterface

	// store the number of instance per gongstruct
	Map_GongStructName_InstancesNb map[string]int

	// store meta package import
	MetaPackageImportPath  string
	MetaPackageImportAlias string

	// to be removed after fix of [issue](https://github.com/golang/go/issues/57559)
	// map to enable docLink renaming when an identifier is renamed
	Map_DocLink_Renaming map[string]GONG__Identifier
	// contains filtered or unexported fields
}

StageStruct enables storage of staged instances swagger:ignore

func NewStage 

func NewStage(path string) (stage *StageStruct)

func (*StageStruct) Backup 

func (stage *StageStruct) Backup(dirPath string)

backup generates backup files in the dirPath

func (*StageStruct) BackupXL 

func (stage *StageStruct) BackupXL(dirPath string)

backup generates backup files in the dirPath

func (*StageStruct) Checkout 

func (stage *StageStruct) Checkout()

func (*StageStruct) Commit 

func (stage *StageStruct) Commit()

func (*StageStruct) CommitWithSuspendedCallbacks 

func (stage *StageStruct) CommitWithSuspendedCallbacks()

func (*StageStruct) ComputeReverseMaps 

func (stage *StageStruct) ComputeReverseMaps()

ComputeReverseMaps computes the reverse map, for all intances, for all slice to pointers field Its complexity is in O(n)O(p) where p is the number of pointers

func (*StageStruct) GetPath 

func (stage *StageStruct) GetPath() string

func (*StageStruct) GetType 

func (stage *StageStruct) GetType() string

func (*StageStruct) IsStagedAccidental 

func (stage *StageStruct) IsStagedAccidental(accidental *Accidental) (ok bool)

insertion point for stage per struct

func (*StageStruct) IsStagedAccidental_mark 

func (stage *StageStruct) IsStagedAccidental_mark(accidental_mark *Accidental_mark) (ok bool)

func (*StageStruct) IsStagedAccidental_text 

func (stage *StageStruct) IsStagedAccidental_text(accidental_text *Accidental_text) (ok bool)

func (*StageStruct) IsStagedAccord 

func (stage *StageStruct) IsStagedAccord(accord *Accord) (ok bool)

func (*StageStruct) IsStagedAccordion_registration 

func (stage *StageStruct) IsStagedAccordion_registration(accordion_registration *Accordion_registration) (ok bool)

func (*StageStruct) IsStagedAnyType 

func (stage *StageStruct) IsStagedAnyType(anytype *AnyType) (ok bool)

func (*StageStruct) IsStagedAppearance 

func (stage *StageStruct) IsStagedAppearance(appearance *Appearance) (ok bool)

func (*StageStruct) IsStagedArpeggiate 

func (stage *StageStruct) IsStagedArpeggiate(arpeggiate *Arpeggiate) (ok bool)

func (*StageStruct) IsStagedArrow 

func (stage *StageStruct) IsStagedArrow(arrow *Arrow) (ok bool)

func (*StageStruct) IsStagedArticulations 

func (stage *StageStruct) IsStagedArticulations(articulations *Articulations) (ok bool)

func (*StageStruct) IsStagedAssess 

func (stage *StageStruct) IsStagedAssess(assess *Assess) (ok bool)

func (*StageStruct) IsStagedAttributes 

func (stage *StageStruct) IsStagedAttributes(attributes *Attributes) (ok bool)

func (*StageStruct) IsStagedBackup 

func (stage *StageStruct) IsStagedBackup(backup *Backup) (ok bool)

func (*StageStruct) IsStagedBar_style_color 

func (stage *StageStruct) IsStagedBar_style_color(bar_style_color *Bar_style_color) (ok bool)

func (*StageStruct) IsStagedBarline 

func (stage *StageStruct) IsStagedBarline(barline *Barline) (ok bool)

func (*StageStruct) IsStagedBarre 

func (stage *StageStruct) IsStagedBarre(barre *Barre) (ok bool)

func (*StageStruct) IsStagedBass 

func (stage *StageStruct) IsStagedBass(bass *Bass) (ok bool)

func (*StageStruct) IsStagedBass_step 

func (stage *StageStruct) IsStagedBass_step(bass_step *Bass_step) (ok bool)

func (*StageStruct) IsStagedBeam 

func (stage *StageStruct) IsStagedBeam(beam *Beam) (ok bool)

func (*StageStruct) IsStagedBeat_repeat 

func (stage *StageStruct) IsStagedBeat_repeat(beat_repeat *Beat_repeat) (ok bool)

func (*StageStruct) IsStagedBeat_unit_tied 

func (stage *StageStruct) IsStagedBeat_unit_tied(beat_unit_tied *Beat_unit_tied) (ok bool)

func (*StageStruct) IsStagedBeater 

func (stage *StageStruct) IsStagedBeater(beater *Beater) (ok bool)

func (*StageStruct) IsStagedBend 

func (stage *StageStruct) IsStagedBend(bend *Bend) (ok bool)

func (*StageStruct) IsStagedBookmark 

func (stage *StageStruct) IsStagedBookmark(bookmark *Bookmark) (ok bool)

func (*StageStruct) IsStagedBracket 

func (stage *StageStruct) IsStagedBracket(bracket *Bracket) (ok bool)

func (*StageStruct) IsStagedBreath_mark 

func (stage *StageStruct) IsStagedBreath_mark(breath_mark *Breath_mark) (ok bool)

func (*StageStruct) IsStagedCaesura 

func (stage *StageStruct) IsStagedCaesura(caesura *Caesura) (ok bool)

func (*StageStruct) IsStagedCancel 

func (stage *StageStruct) IsStagedCancel(cancel *Cancel) (ok bool)

func (*StageStruct) IsStagedClef 

func (stage *StageStruct) IsStagedClef(clef *Clef) (ok bool)

func (*StageStruct) IsStagedCoda 

func (stage *StageStruct) IsStagedCoda(coda *Coda) (ok bool)

func (*StageStruct) IsStagedCredit 

func (stage *StageStruct) IsStagedCredit(credit *Credit) (ok bool)

func (*StageStruct) IsStagedDashes 

func (stage *StageStruct) IsStagedDashes(dashes *Dashes) (ok bool)

func (*StageStruct) IsStagedDefaults 

func (stage *StageStruct) IsStagedDefaults(defaults *Defaults) (ok bool)

func (*StageStruct) IsStagedDegree 

func (stage *StageStruct) IsStagedDegree(degree *Degree) (ok bool)

func (*StageStruct) IsStagedDegree_alter 

func (stage *StageStruct) IsStagedDegree_alter(degree_alter *Degree_alter) (ok bool)

func (*StageStruct) IsStagedDegree_type 

func (stage *StageStruct) IsStagedDegree_type(degree_type *Degree_type) (ok bool)

func (*StageStruct) IsStagedDegree_value 

func (stage *StageStruct) IsStagedDegree_value(degree_value *Degree_value) (ok bool)

func (*StageStruct) IsStagedDirection 

func (stage *StageStruct) IsStagedDirection(direction *Direction) (ok bool)

func (*StageStruct) IsStagedDirection_type 

func (stage *StageStruct) IsStagedDirection_type(direction_type *Direction_type) (ok bool)

func (*StageStruct) IsStagedDistance 

func (stage *StageStruct) IsStagedDistance(distance *Distance) (ok bool)

func (*StageStruct) IsStagedDouble 

func (stage *StageStruct) IsStagedDouble(double *Double) (ok bool)

func (*StageStruct) IsStagedDynamics 

func (stage *StageStruct) IsStagedDynamics(dynamics *Dynamics) (ok bool)

func (*StageStruct) IsStagedEffect 

func (stage *StageStruct) IsStagedEffect(effect *Effect) (ok bool)

func (*StageStruct) IsStagedElision 

func (stage *StageStruct) IsStagedElision(elision *Elision) (ok bool)

func (*StageStruct) IsStagedEmpty 

func (stage *StageStruct) IsStagedEmpty(empty *Empty) (ok bool)

func (*StageStruct) IsStagedEmpty_font 

func (stage *StageStruct) IsStagedEmpty_font(empty_font *Empty_font) (ok bool)

func (*StageStruct) IsStagedEmpty_line 

func (stage *StageStruct) IsStagedEmpty_line(empty_line *Empty_line) (ok bool)

func (*StageStruct) IsStagedEmpty_placement 

func (stage *StageStruct) IsStagedEmpty_placement(empty_placement *Empty_placement) (ok bool)

func (*StageStruct) IsStagedEmpty_placement_smufl 

func (stage *StageStruct) IsStagedEmpty_placement_smufl(empty_placement_smufl *Empty_placement_smufl) (ok bool)

func (*StageStruct) IsStagedEmpty_print_object_style_align 

func (stage *StageStruct) IsStagedEmpty_print_object_style_align(empty_print_object_style_align *Empty_print_object_style_align) (ok bool)

func (*StageStruct) IsStagedEmpty_print_style 

func (stage *StageStruct) IsStagedEmpty_print_style(empty_print_style *Empty_print_style) (ok bool)

func (*StageStruct) IsStagedEmpty_print_style_align 

func (stage *StageStruct) IsStagedEmpty_print_style_align(empty_print_style_align *Empty_print_style_align) (ok bool)

func (*StageStruct) IsStagedEmpty_print_style_align_id 

func (stage *StageStruct) IsStagedEmpty_print_style_align_id(empty_print_style_align_id *Empty_print_style_align_id) (ok bool)

func (*StageStruct) IsStagedEmpty_trill_sound 

func (stage *StageStruct) IsStagedEmpty_trill_sound(empty_trill_sound *Empty_trill_sound) (ok bool)

func (*StageStruct) IsStagedEncoding 

func (stage *StageStruct) IsStagedEncoding(encoding *Encoding) (ok bool)

func (*StageStruct) IsStagedEnding 

func (stage *StageStruct) IsStagedEnding(ending *Ending) (ok bool)

func (*StageStruct) IsStagedExtend 

func (stage *StageStruct) IsStagedExtend(extend *Extend) (ok bool)

func (*StageStruct) IsStagedFeature 

func (stage *StageStruct) IsStagedFeature(feature *Feature) (ok bool)

func (*StageStruct) IsStagedFermata 

func (stage *StageStruct) IsStagedFermata(fermata *Fermata) (ok bool)

func (*StageStruct) IsStagedFigure 

func (stage *StageStruct) IsStagedFigure(figure *Figure) (ok bool)

func (*StageStruct) IsStagedFigured_bass 

func (stage *StageStruct) IsStagedFigured_bass(figured_bass *Figured_bass) (ok bool)

func (*StageStruct) IsStagedFingering 

func (stage *StageStruct) IsStagedFingering(fingering *Fingering) (ok bool)

func (*StageStruct) IsStagedFirst_fret 

func (stage *StageStruct) IsStagedFirst_fret(first_fret *First_fret) (ok bool)

func (*StageStruct) IsStagedFoo 

func (stage *StageStruct) IsStagedFoo(foo *Foo) (ok bool)

func (*StageStruct) IsStagedFor_part 

func (stage *StageStruct) IsStagedFor_part(for_part *For_part) (ok bool)

func (*StageStruct) IsStagedFormatted_symbol 

func (stage *StageStruct) IsStagedFormatted_symbol(formatted_symbol *Formatted_symbol) (ok bool)

func (*StageStruct) IsStagedFormatted_symbol_id 

func (stage *StageStruct) IsStagedFormatted_symbol_id(formatted_symbol_id *Formatted_symbol_id) (ok bool)

func (*StageStruct) IsStagedForward 

func (stage *StageStruct) IsStagedForward(forward *Forward) (ok bool)

func (*StageStruct) IsStagedFrame 

func (stage *StageStruct) IsStagedFrame(frame *Frame) (ok bool)

func (*StageStruct) IsStagedFrame_note 

func (stage *StageStruct) IsStagedFrame_note(frame_note *Frame_note) (ok bool)

func (*StageStruct) IsStagedFret 

func (stage *StageStruct) IsStagedFret(fret *Fret) (ok bool)

func (*StageStruct) IsStagedGlass 

func (stage *StageStruct) IsStagedGlass(glass *Glass) (ok bool)

func (*StageStruct) IsStagedGlissando 

func (stage *StageStruct) IsStagedGlissando(glissando *Glissando) (ok bool)

func (*StageStruct) IsStagedGlyph 

func (stage *StageStruct) IsStagedGlyph(glyph *Glyph) (ok bool)

func (*StageStruct) IsStagedGrace 

func (stage *StageStruct) IsStagedGrace(grace *Grace) (ok bool)

func (*StageStruct) IsStagedGroup_barline 

func (stage *StageStruct) IsStagedGroup_barline(group_barline *Group_barline) (ok bool)

func (*StageStruct) IsStagedGroup_symbol 

func (stage *StageStruct) IsStagedGroup_symbol(group_symbol *Group_symbol) (ok bool)

func (*StageStruct) IsStagedGrouping 

func (stage *StageStruct) IsStagedGrouping(grouping *Grouping) (ok bool)

func (*StageStruct) IsStagedHammer_on_pull_off 

func (stage *StageStruct) IsStagedHammer_on_pull_off(hammer_on_pull_off *Hammer_on_pull_off) (ok bool)

func (*StageStruct) IsStagedHandbell 

func (stage *StageStruct) IsStagedHandbell(handbell *Handbell) (ok bool)

func (*StageStruct) IsStagedHarmon_closed 

func (stage *StageStruct) IsStagedHarmon_closed(harmon_closed *Harmon_closed) (ok bool)

func (*StageStruct) IsStagedHarmon_mute 

func (stage *StageStruct) IsStagedHarmon_mute(harmon_mute *Harmon_mute) (ok bool)

func (*StageStruct) IsStagedHarmonic 

func (stage *StageStruct) IsStagedHarmonic(harmonic *Harmonic) (ok bool)

func (*StageStruct) IsStagedHarmony 

func (stage *StageStruct) IsStagedHarmony(harmony *Harmony) (ok bool)

func (*StageStruct) IsStagedHarmony_alter 

func (stage *StageStruct) IsStagedHarmony_alter(harmony_alter *Harmony_alter) (ok bool)

func (*StageStruct) IsStagedHarp_pedals 

func (stage *StageStruct) IsStagedHarp_pedals(harp_pedals *Harp_pedals) (ok bool)

func (*StageStruct) IsStagedHeel_toe 

func (stage *StageStruct) IsStagedHeel_toe(heel_toe *Heel_toe) (ok bool)

func (*StageStruct) IsStagedHole 

func (stage *StageStruct) IsStagedHole(hole *Hole) (ok bool)

func (*StageStruct) IsStagedHole_closed 

func (stage *StageStruct) IsStagedHole_closed(hole_closed *Hole_closed) (ok bool)

func (*StageStruct) IsStagedHorizontal_turn 

func (stage *StageStruct) IsStagedHorizontal_turn(horizontal_turn *Horizontal_turn) (ok bool)

func (*StageStruct) IsStagedIdentification 

func (stage *StageStruct) IsStagedIdentification(identification *Identification) (ok bool)

func (*StageStruct) IsStagedImage 

func (stage *StageStruct) IsStagedImage(image *Image) (ok bool)

func (*StageStruct) IsStagedInstrument 

func (stage *StageStruct) IsStagedInstrument(instrument *Instrument) (ok bool)

func (*StageStruct) IsStagedInstrument_change 

func (stage *StageStruct) IsStagedInstrument_change(instrument_change *Instrument_change) (ok bool)
func (stage *StageStruct) IsStagedInstrument_link(instrument_link *Instrument_link) (ok bool)

func (*StageStruct) IsStagedInterchangeable 

func (stage *StageStruct) IsStagedInterchangeable(interchangeable *Interchangeable) (ok bool)

func (*StageStruct) IsStagedInversion 

func (stage *StageStruct) IsStagedInversion(inversion *Inversion) (ok bool)

func (*StageStruct) IsStagedKey 

func (stage *StageStruct) IsStagedKey(key *Key) (ok bool)

func (*StageStruct) IsStagedKey_accidental 

func (stage *StageStruct) IsStagedKey_accidental(key_accidental *Key_accidental) (ok bool)

func (*StageStruct) IsStagedKey_octave 

func (stage *StageStruct) IsStagedKey_octave(key_octave *Key_octave) (ok bool)

func (*StageStruct) IsStagedKind 

func (stage *StageStruct) IsStagedKind(kind *Kind) (ok bool)

func (*StageStruct) IsStagedLevel 

func (stage *StageStruct) IsStagedLevel(level *Level) (ok bool)

func (*StageStruct) IsStagedLine_detail 

func (stage *StageStruct) IsStagedLine_detail(line_detail *Line_detail) (ok bool)

func (*StageStruct) IsStagedLine_width 

func (stage *StageStruct) IsStagedLine_width(line_width *Line_width) (ok bool)
func (stage *StageStruct) IsStagedLink(link *Link) (ok bool)

func (*StageStruct) IsStagedListen 

func (stage *StageStruct) IsStagedListen(listen *Listen) (ok bool)

func (*StageStruct) IsStagedListening 

func (stage *StageStruct) IsStagedListening(listening *Listening) (ok bool)

func (*StageStruct) IsStagedLyric 

func (stage *StageStruct) IsStagedLyric(lyric *Lyric) (ok bool)

func (*StageStruct) IsStagedLyric_font 

func (stage *StageStruct) IsStagedLyric_font(lyric_font *Lyric_font) (ok bool)

func (*StageStruct) IsStagedLyric_language 

func (stage *StageStruct) IsStagedLyric_language(lyric_language *Lyric_language) (ok bool)

func (*StageStruct) IsStagedMeasure_layout 

func (stage *StageStruct) IsStagedMeasure_layout(measure_layout *Measure_layout) (ok bool)

func (*StageStruct) IsStagedMeasure_numbering 

func (stage *StageStruct) IsStagedMeasure_numbering(measure_numbering *Measure_numbering) (ok bool)

func (*StageStruct) IsStagedMeasure_repeat 

func (stage *StageStruct) IsStagedMeasure_repeat(measure_repeat *Measure_repeat) (ok bool)

func (*StageStruct) IsStagedMeasure_style 

func (stage *StageStruct) IsStagedMeasure_style(measure_style *Measure_style) (ok bool)

func (*StageStruct) IsStagedMembrane 

func (stage *StageStruct) IsStagedMembrane(membrane *Membrane) (ok bool)

func (*StageStruct) IsStagedMetal 

func (stage *StageStruct) IsStagedMetal(metal *Metal) (ok bool)

func (*StageStruct) IsStagedMetronome 

func (stage *StageStruct) IsStagedMetronome(metronome *Metronome) (ok bool)

func (*StageStruct) IsStagedMetronome_beam 

func (stage *StageStruct) IsStagedMetronome_beam(metronome_beam *Metronome_beam) (ok bool)

func (*StageStruct) IsStagedMetronome_note 

func (stage *StageStruct) IsStagedMetronome_note(metronome_note *Metronome_note) (ok bool)

func (*StageStruct) IsStagedMetronome_tied 

func (stage *StageStruct) IsStagedMetronome_tied(metronome_tied *Metronome_tied) (ok bool)

func (*StageStruct) IsStagedMetronome_tuplet 

func (stage *StageStruct) IsStagedMetronome_tuplet(metronome_tuplet *Metronome_tuplet) (ok bool)

func (*StageStruct) IsStagedMidi_device 

func (stage *StageStruct) IsStagedMidi_device(midi_device *Midi_device) (ok bool)

func (*StageStruct) IsStagedMidi_instrument 

func (stage *StageStruct) IsStagedMidi_instrument(midi_instrument *Midi_instrument) (ok bool)

func (*StageStruct) IsStagedMiscellaneous 

func (stage *StageStruct) IsStagedMiscellaneous(miscellaneous *Miscellaneous) (ok bool)

func (*StageStruct) IsStagedMiscellaneous_field 

func (stage *StageStruct) IsStagedMiscellaneous_field(miscellaneous_field *Miscellaneous_field) (ok bool)

func (*StageStruct) IsStagedMordent 

func (stage *StageStruct) IsStagedMordent(mordent *Mordent) (ok bool)

func (*StageStruct) IsStagedMultiple_rest 

func (stage *StageStruct) IsStagedMultiple_rest(multiple_rest *Multiple_rest) (ok bool)

func (*StageStruct) IsStagedName_display 

func (stage *StageStruct) IsStagedName_display(name_display *Name_display) (ok bool)

func (*StageStruct) IsStagedNon_arpeggiate 

func (stage *StageStruct) IsStagedNon_arpeggiate(non_arpeggiate *Non_arpeggiate) (ok bool)

func (*StageStruct) IsStagedNotations 

func (stage *StageStruct) IsStagedNotations(notations *Notations) (ok bool)

func (*StageStruct) IsStagedNote 

func (stage *StageStruct) IsStagedNote(note *Note) (ok bool)

func (*StageStruct) IsStagedNote_size 

func (stage *StageStruct) IsStagedNote_size(note_size *Note_size) (ok bool)

func (*StageStruct) IsStagedNote_type 

func (stage *StageStruct) IsStagedNote_type(note_type *Note_type) (ok bool)

func (*StageStruct) IsStagedNotehead 

func (stage *StageStruct) IsStagedNotehead(notehead *Notehead) (ok bool)

func (*StageStruct) IsStagedNotehead_text 

func (stage *StageStruct) IsStagedNotehead_text(notehead_text *Notehead_text) (ok bool)

func (*StageStruct) IsStagedNumeral 

func (stage *StageStruct) IsStagedNumeral(numeral *Numeral) (ok bool)

func (*StageStruct) IsStagedNumeral_key 

func (stage *StageStruct) IsStagedNumeral_key(numeral_key *Numeral_key) (ok bool)

func (*StageStruct) IsStagedNumeral_root 

func (stage *StageStruct) IsStagedNumeral_root(numeral_root *Numeral_root) (ok bool)

func (*StageStruct) IsStagedOctave_shift 

func (stage *StageStruct) IsStagedOctave_shift(octave_shift *Octave_shift) (ok bool)

func (*StageStruct) IsStagedOffset 

func (stage *StageStruct) IsStagedOffset(offset *Offset) (ok bool)

func (*StageStruct) IsStagedOpus 

func (stage *StageStruct) IsStagedOpus(opus *Opus) (ok bool)

func (*StageStruct) IsStagedOrnaments 

func (stage *StageStruct) IsStagedOrnaments(ornaments *Ornaments) (ok bool)

func (*StageStruct) IsStagedOther_appearance 

func (stage *StageStruct) IsStagedOther_appearance(other_appearance *Other_appearance) (ok bool)

func (*StageStruct) IsStagedOther_listening 

func (stage *StageStruct) IsStagedOther_listening(other_listening *Other_listening) (ok bool)

func (*StageStruct) IsStagedOther_notation 

func (stage *StageStruct) IsStagedOther_notation(other_notation *Other_notation) (ok bool)

func (*StageStruct) IsStagedOther_play 

func (stage *StageStruct) IsStagedOther_play(other_play *Other_play) (ok bool)

func (*StageStruct) IsStagedPage_layout 

func (stage *StageStruct) IsStagedPage_layout(page_layout *Page_layout) (ok bool)

func (*StageStruct) IsStagedPage_margins 

func (stage *StageStruct) IsStagedPage_margins(page_margins *Page_margins) (ok bool)

func (*StageStruct) IsStagedPart_clef 

func (stage *StageStruct) IsStagedPart_clef(part_clef *Part_clef) (ok bool)

func (*StageStruct) IsStagedPart_group 

func (stage *StageStruct) IsStagedPart_group(part_group *Part_group) (ok bool)
func (stage *StageStruct) IsStagedPart_link(part_link *Part_link) (ok bool)

func (*StageStruct) IsStagedPart_list 

func (stage *StageStruct) IsStagedPart_list(part_list *Part_list) (ok bool)

func (*StageStruct) IsStagedPart_symbol 

func (stage *StageStruct) IsStagedPart_symbol(part_symbol *Part_symbol) (ok bool)

func (*StageStruct) IsStagedPart_transpose 

func (stage *StageStruct) IsStagedPart_transpose(part_transpose *Part_transpose) (ok bool)

func (*StageStruct) IsStagedPedal 

func (stage *StageStruct) IsStagedPedal(pedal *Pedal) (ok bool)

func (*StageStruct) IsStagedPedal_tuning 

func (stage *StageStruct) IsStagedPedal_tuning(pedal_tuning *Pedal_tuning) (ok bool)

func (*StageStruct) IsStagedPercussion 

func (stage *StageStruct) IsStagedPercussion(percussion *Percussion) (ok bool)

func (*StageStruct) IsStagedPitch 

func (stage *StageStruct) IsStagedPitch(pitch *Pitch) (ok bool)

func (*StageStruct) IsStagedPitched 

func (stage *StageStruct) IsStagedPitched(pitched *Pitched) (ok bool)

func (*StageStruct) IsStagedPlay 

func (stage *StageStruct) IsStagedPlay(play *Play) (ok bool)

func (*StageStruct) IsStagedPlayer 

func (stage *StageStruct) IsStagedPlayer(player *Player) (ok bool)

func (*StageStruct) IsStagedPrincipal_voice 

func (stage *StageStruct) IsStagedPrincipal_voice(principal_voice *Principal_voice) (ok bool)

func (*StageStruct) IsStagedPrint 

func (stage *StageStruct) IsStagedPrint(print *Print) (ok bool)

func (*StageStruct) IsStagedRelease 

func (stage *StageStruct) IsStagedRelease(release *Release) (ok bool)

func (*StageStruct) IsStagedRepeat 

func (stage *StageStruct) IsStagedRepeat(repeat *Repeat) (ok bool)

func (*StageStruct) IsStagedRest 

func (stage *StageStruct) IsStagedRest(rest *Rest) (ok bool)

func (*StageStruct) IsStagedRoot 

func (stage *StageStruct) IsStagedRoot(root *Root) (ok bool)

func (*StageStruct) IsStagedRoot_step 

func (stage *StageStruct) IsStagedRoot_step(root_step *Root_step) (ok bool)

func (*StageStruct) IsStagedScaling 

func (stage *StageStruct) IsStagedScaling(scaling *Scaling) (ok bool)

func (*StageStruct) IsStagedScordatura 

func (stage *StageStruct) IsStagedScordatura(scordatura *Scordatura) (ok bool)

func (*StageStruct) IsStagedScore_instrument 

func (stage *StageStruct) IsStagedScore_instrument(score_instrument *Score_instrument) (ok bool)

func (*StageStruct) IsStagedScore_part 

func (stage *StageStruct) IsStagedScore_part(score_part *Score_part) (ok bool)

func (*StageStruct) IsStagedScore_partwise 

func (stage *StageStruct) IsStagedScore_partwise(score_partwise *Score_partwise) (ok bool)

func (*StageStruct) IsStagedScore_timewise 

func (stage *StageStruct) IsStagedScore_timewise(score_timewise *Score_timewise) (ok bool)

func (*StageStruct) IsStagedSegno 

func (stage *StageStruct) IsStagedSegno(segno *Segno) (ok bool)

func (*StageStruct) IsStagedSlash 

func (stage *StageStruct) IsStagedSlash(slash *Slash) (ok bool)

func (*StageStruct) IsStagedSlide 

func (stage *StageStruct) IsStagedSlide(slide *Slide) (ok bool)

func (*StageStruct) IsStagedSlur 

func (stage *StageStruct) IsStagedSlur(slur *Slur) (ok bool)

func (*StageStruct) IsStagedSound 

func (stage *StageStruct) IsStagedSound(sound *Sound) (ok bool)

func (*StageStruct) IsStagedStaff_details 

func (stage *StageStruct) IsStagedStaff_details(staff_details *Staff_details) (ok bool)

func (*StageStruct) IsStagedStaff_divide 

func (stage *StageStruct) IsStagedStaff_divide(staff_divide *Staff_divide) (ok bool)

func (*StageStruct) IsStagedStaff_layout 

func (stage *StageStruct) IsStagedStaff_layout(staff_layout *Staff_layout) (ok bool)

func (*StageStruct) IsStagedStaff_size 

func (stage *StageStruct) IsStagedStaff_size(staff_size *Staff_size) (ok bool)

func (*StageStruct) IsStagedStaff_tuning 

func (stage *StageStruct) IsStagedStaff_tuning(staff_tuning *Staff_tuning) (ok bool)

func (*StageStruct) IsStagedStem 

func (stage *StageStruct) IsStagedStem(stem *Stem) (ok bool)

func (*StageStruct) IsStagedStick 

func (stage *StageStruct) IsStagedStick(stick *Stick) (ok bool)

func (*StageStruct) IsStagedString_mute 

func (stage *StageStruct) IsStagedString_mute(string_mute *String_mute) (ok bool)

func (*StageStruct) IsStagedStrong_accent 

func (stage *StageStruct) IsStagedStrong_accent(strong_accent *Strong_accent) (ok bool)

func (*StageStruct) IsStagedSupports 

func (stage *StageStruct) IsStagedSupports(supports *Supports) (ok bool)

func (*StageStruct) IsStagedSwing 

func (stage *StageStruct) IsStagedSwing(swing *Swing) (ok bool)

func (*StageStruct) IsStagedSync 

func (stage *StageStruct) IsStagedSync(sync *Sync) (ok bool)

func (*StageStruct) IsStagedSystem_dividers 

func (stage *StageStruct) IsStagedSystem_dividers(system_dividers *System_dividers) (ok bool)

func (*StageStruct) IsStagedSystem_layout 

func (stage *StageStruct) IsStagedSystem_layout(system_layout *System_layout) (ok bool)

func (*StageStruct) IsStagedSystem_margins 

func (stage *StageStruct) IsStagedSystem_margins(system_margins *System_margins) (ok bool)

func (*StageStruct) IsStagedTap 

func (stage *StageStruct) IsStagedTap(tap *Tap) (ok bool)

func (*StageStruct) IsStagedTechnical 

func (stage *StageStruct) IsStagedTechnical(technical *Technical) (ok bool)

func (*StageStruct) IsStagedText_element_data 

func (stage *StageStruct) IsStagedText_element_data(text_element_data *Text_element_data) (ok bool)

func (*StageStruct) IsStagedTie 

func (stage *StageStruct) IsStagedTie(tie *Tie) (ok bool)

func (*StageStruct) IsStagedTied 

func (stage *StageStruct) IsStagedTied(tied *Tied) (ok bool)

func (*StageStruct) IsStagedTime 

func (stage *StageStruct) IsStagedTime(time *Time) (ok bool)

func (*StageStruct) IsStagedTime_modification 

func (stage *StageStruct) IsStagedTime_modification(time_modification *Time_modification) (ok bool)

func (*StageStruct) IsStagedTimpani 

func (stage *StageStruct) IsStagedTimpani(timpani *Timpani) (ok bool)

func (*StageStruct) IsStagedTranspose 

func (stage *StageStruct) IsStagedTranspose(transpose *Transpose) (ok bool)

func (*StageStruct) IsStagedTremolo 

func (stage *StageStruct) IsStagedTremolo(tremolo *Tremolo) (ok bool)

func (*StageStruct) IsStagedTuplet 

func (stage *StageStruct) IsStagedTuplet(tuplet *Tuplet) (ok bool)

func (*StageStruct) IsStagedTuplet_dot 

func (stage *StageStruct) IsStagedTuplet_dot(tuplet_dot *Tuplet_dot) (ok bool)

func (*StageStruct) IsStagedTuplet_number 

func (stage *StageStruct) IsStagedTuplet_number(tuplet_number *Tuplet_number) (ok bool)

func (*StageStruct) IsStagedTuplet_portion 

func (stage *StageStruct) IsStagedTuplet_portion(tuplet_portion *Tuplet_portion) (ok bool)

func (*StageStruct) IsStagedTuplet_type 

func (stage *StageStruct) IsStagedTuplet_type(tuplet_type *Tuplet_type) (ok bool)

func (*StageStruct) IsStagedTyped_text 

func (stage *StageStruct) IsStagedTyped_text(typed_text *Typed_text) (ok bool)

func (*StageStruct) IsStagedUnpitched 

func (stage *StageStruct) IsStagedUnpitched(unpitched *Unpitched) (ok bool)

func (*StageStruct) IsStagedVirtual_instrument 

func (stage *StageStruct) IsStagedVirtual_instrument(virtual_instrument *Virtual_instrument) (ok bool)

func (*StageStruct) IsStagedWait 

func (stage *StageStruct) IsStagedWait(wait *Wait) (ok bool)

func (*StageStruct) IsStagedWavy_line 

func (stage *StageStruct) IsStagedWavy_line(wavy_line *Wavy_line) (ok bool)

func (*StageStruct) IsStagedWedge 

func (stage *StageStruct) IsStagedWedge(wedge *Wedge) (ok bool)

func (*StageStruct) IsStagedWood 

func (stage *StageStruct) IsStagedWood(wood *Wood) (ok bool)

func (*StageStruct) IsStagedWork 

func (stage *StageStruct) IsStagedWork(work *Work) (ok bool)

func (*StageStruct) Marshall 

func (stage *StageStruct) Marshall(file *os.File, modelsPackageName, packageName string)

Marshall marshall the stage content into the file as an instanciation into a stage

func (*StageStruct) Nil 

func (stage *StageStruct) Nil()

func (*StageStruct) Reset 

func (stage *StageStruct) Reset()

func (*StageStruct) Restore 

func (stage *StageStruct) Restore(dirPath string)

Restore resets Stage & BackRepo and restores their content from the restore files in dirPath

func (*StageStruct) RestoreXL 

func (stage *StageStruct) RestoreXL(dirPath string)

Restore resets Stage & BackRepo and restores their content from the restore files in dirPath

func (*StageStruct) StageBranchAccidental 

func (stage *StageStruct) StageBranchAccidental(accidental *Accidental)

insertion point for stage branch per struct

func (*StageStruct) StageBranchAccidental_mark 

func (stage *StageStruct) StageBranchAccidental_mark(accidental_mark *Accidental_mark)

func (*StageStruct) StageBranchAccidental_text 

func (stage *StageStruct) StageBranchAccidental_text(accidental_text *Accidental_text)

func (*StageStruct) StageBranchAccord 

func (stage *StageStruct) StageBranchAccord(accord *Accord)

func (*StageStruct) StageBranchAccordion_registration 

func (stage *StageStruct) StageBranchAccordion_registration(accordion_registration *Accordion_registration)

func (*StageStruct) StageBranchAnyType 

func (stage *StageStruct) StageBranchAnyType(anytype *AnyType)

func (*StageStruct) StageBranchAppearance 

func (stage *StageStruct) StageBranchAppearance(appearance *Appearance)

func (*StageStruct) StageBranchArpeggiate 

func (stage *StageStruct) StageBranchArpeggiate(arpeggiate *Arpeggiate)

func (*StageStruct) StageBranchArrow 

func (stage *StageStruct) StageBranchArrow(arrow *Arrow)

func (*StageStruct) StageBranchArticulations 

func (stage *StageStruct) StageBranchArticulations(articulations *Articulations)

func (*StageStruct) StageBranchAssess 

func (stage *StageStruct) StageBranchAssess(assess *Assess)

func (*StageStruct) StageBranchAttributes 

func (stage *StageStruct) StageBranchAttributes(attributes *Attributes)

func (*StageStruct) StageBranchBackup 

func (stage *StageStruct) StageBranchBackup(backup *Backup)

func (*StageStruct) StageBranchBar_style_color 

func (stage *StageStruct) StageBranchBar_style_color(bar_style_color *Bar_style_color)

func (*StageStruct) StageBranchBarline 

func (stage *StageStruct) StageBranchBarline(barline *Barline)

func (*StageStruct) StageBranchBarre 

func (stage *StageStruct) StageBranchBarre(barre *Barre)

func (*StageStruct) StageBranchBass 

func (stage *StageStruct) StageBranchBass(bass *Bass)

func (*StageStruct) StageBranchBass_step 

func (stage *StageStruct) StageBranchBass_step(bass_step *Bass_step)

func (*StageStruct) StageBranchBeam 

func (stage *StageStruct) StageBranchBeam(beam *Beam)

func (*StageStruct) StageBranchBeat_repeat 

func (stage *StageStruct) StageBranchBeat_repeat(beat_repeat *Beat_repeat)

func (*StageStruct) StageBranchBeat_unit_tied 

func (stage *StageStruct) StageBranchBeat_unit_tied(beat_unit_tied *Beat_unit_tied)

func (*StageStruct) StageBranchBeater 

func (stage *StageStruct) StageBranchBeater(beater *Beater)

func (*StageStruct) StageBranchBend 

func (stage *StageStruct) StageBranchBend(bend *Bend)

func (*StageStruct) StageBranchBookmark 

func (stage *StageStruct) StageBranchBookmark(bookmark *Bookmark)

func (*StageStruct) StageBranchBracket 

func (stage *StageStruct) StageBranchBracket(bracket *Bracket)

func (*StageStruct) StageBranchBreath_mark 

func (stage *StageStruct) StageBranchBreath_mark(breath_mark *Breath_mark)

func (*StageStruct) StageBranchCaesura 

func (stage *StageStruct) StageBranchCaesura(caesura *Caesura)

func (*StageStruct) StageBranchCancel 

func (stage *StageStruct) StageBranchCancel(cancel *Cancel)

func (*StageStruct) StageBranchClef 

func (stage *StageStruct) StageBranchClef(clef *Clef)

func (*StageStruct) StageBranchCoda 

func (stage *StageStruct) StageBranchCoda(coda *Coda)

func (*StageStruct) StageBranchCredit 

func (stage *StageStruct) StageBranchCredit(credit *Credit)

func (*StageStruct) StageBranchDashes 

func (stage *StageStruct) StageBranchDashes(dashes *Dashes)

func (*StageStruct) StageBranchDefaults 

func (stage *StageStruct) StageBranchDefaults(defaults *Defaults)

func (*StageStruct) StageBranchDegree 

func (stage *StageStruct) StageBranchDegree(degree *Degree)

func (*StageStruct) StageBranchDegree_alter 

func (stage *StageStruct) StageBranchDegree_alter(degree_alter *Degree_alter)

func (*StageStruct) StageBranchDegree_type 

func (stage *StageStruct) StageBranchDegree_type(degree_type *Degree_type)

func (*StageStruct) StageBranchDegree_value 

func (stage *StageStruct) StageBranchDegree_value(degree_value *Degree_value)

func (*StageStruct) StageBranchDirection 

func (stage *StageStruct) StageBranchDirection(direction *Direction)

func (*StageStruct) StageBranchDirection_type 

func (stage *StageStruct) StageBranchDirection_type(direction_type *Direction_type)

func (*StageStruct) StageBranchDistance 

func (stage *StageStruct) StageBranchDistance(distance *Distance)

func (*StageStruct) StageBranchDouble 

func (stage *StageStruct) StageBranchDouble(double *Double)

func (*StageStruct) StageBranchDynamics 

func (stage *StageStruct) StageBranchDynamics(dynamics *Dynamics)

func (*StageStruct) StageBranchEffect 

func (stage *StageStruct) StageBranchEffect(effect *Effect)

func (*StageStruct) StageBranchElision 

func (stage *StageStruct) StageBranchElision(elision *Elision)

func (*StageStruct) StageBranchEmpty 

func (stage *StageStruct) StageBranchEmpty(empty *Empty)

func (*StageStruct) StageBranchEmpty_font 

func (stage *StageStruct) StageBranchEmpty_font(empty_font *Empty_font)

func (*StageStruct) StageBranchEmpty_line 

func (stage *StageStruct) StageBranchEmpty_line(empty_line *Empty_line)

func (*StageStruct) StageBranchEmpty_placement 

func (stage *StageStruct) StageBranchEmpty_placement(empty_placement *Empty_placement)

func (*StageStruct) StageBranchEmpty_placement_smufl 

func (stage *StageStruct) StageBranchEmpty_placement_smufl(empty_placement_smufl *Empty_placement_smufl)

func (*StageStruct) StageBranchEmpty_print_object_style_align 

func (stage *StageStruct) StageBranchEmpty_print_object_style_align(empty_print_object_style_align *Empty_print_object_style_align)

func (*StageStruct) StageBranchEmpty_print_style 

func (stage *StageStruct) StageBranchEmpty_print_style(empty_print_style *Empty_print_style)

func (*StageStruct) StageBranchEmpty_print_style_align 

func (stage *StageStruct) StageBranchEmpty_print_style_align(empty_print_style_align *Empty_print_style_align)

func (*StageStruct) StageBranchEmpty_print_style_align_id 

func (stage *StageStruct) StageBranchEmpty_print_style_align_id(empty_print_style_align_id *Empty_print_style_align_id)

func (*StageStruct) StageBranchEmpty_trill_sound 

func (stage *StageStruct) StageBranchEmpty_trill_sound(empty_trill_sound *Empty_trill_sound)

func (*StageStruct) StageBranchEncoding 

func (stage *StageStruct) StageBranchEncoding(encoding *Encoding)

func (*StageStruct) StageBranchEnding 

func (stage *StageStruct) StageBranchEnding(ending *Ending)

func (*StageStruct) StageBranchExtend 

func (stage *StageStruct) StageBranchExtend(extend *Extend)

func (*StageStruct) StageBranchFeature 

func (stage *StageStruct) StageBranchFeature(feature *Feature)

func (*StageStruct) StageBranchFermata 

func (stage *StageStruct) StageBranchFermata(fermata *Fermata)

func (*StageStruct) StageBranchFigure 

func (stage *StageStruct) StageBranchFigure(figure *Figure)

func (*StageStruct) StageBranchFigured_bass 

func (stage *StageStruct) StageBranchFigured_bass(figured_bass *Figured_bass)

func (*StageStruct) StageBranchFingering 

func (stage *StageStruct) StageBranchFingering(fingering *Fingering)

func (*StageStruct) StageBranchFirst_fret 

func (stage *StageStruct) StageBranchFirst_fret(first_fret *First_fret)

func (*StageStruct) StageBranchFoo 

func (stage *StageStruct) StageBranchFoo(foo *Foo)

func (*StageStruct) StageBranchFor_part 

func (stage *StageStruct) StageBranchFor_part(for_part *For_part)

func (*StageStruct) StageBranchFormatted_symbol 

func (stage *StageStruct) StageBranchFormatted_symbol(formatted_symbol *Formatted_symbol)

func (*StageStruct) StageBranchFormatted_symbol_id 

func (stage *StageStruct) StageBranchFormatted_symbol_id(formatted_symbol_id *Formatted_symbol_id)

func (*StageStruct) StageBranchForward 

func (stage *StageStruct) StageBranchForward(forward *Forward)

func (*StageStruct) StageBranchFrame 

func (stage *StageStruct) StageBranchFrame(frame *Frame)

func (*StageStruct) StageBranchFrame_note 

func (stage *StageStruct) StageBranchFrame_note(frame_note *Frame_note)

func (*StageStruct) StageBranchFret 

func (stage *StageStruct) StageBranchFret(fret *Fret)

func (*StageStruct) StageBranchGlass 

func (stage *StageStruct) StageBranchGlass(glass *Glass)

func (*StageStruct) StageBranchGlissando 

func (stage *StageStruct) StageBranchGlissando(glissando *Glissando)

func (*StageStruct) StageBranchGlyph 

func (stage *StageStruct) StageBranchGlyph(glyph *Glyph)

func (*StageStruct) StageBranchGrace 

func (stage *StageStruct) StageBranchGrace(grace *Grace)

func (*StageStruct) StageBranchGroup_barline 

func (stage *StageStruct) StageBranchGroup_barline(group_barline *Group_barline)

func (*StageStruct) StageBranchGroup_symbol 

func (stage *StageStruct) StageBranchGroup_symbol(group_symbol *Group_symbol)

func (*StageStruct) StageBranchGrouping 

func (stage *StageStruct) StageBranchGrouping(grouping *Grouping)

func (*StageStruct) StageBranchHammer_on_pull_off 

func (stage *StageStruct) StageBranchHammer_on_pull_off(hammer_on_pull_off *Hammer_on_pull_off)

func (*StageStruct) StageBranchHandbell 

func (stage *StageStruct) StageBranchHandbell(handbell *Handbell)

func (*StageStruct) StageBranchHarmon_closed 

func (stage *StageStruct) StageBranchHarmon_closed(harmon_closed *Harmon_closed)

func (*StageStruct) StageBranchHarmon_mute 

func (stage *StageStruct) StageBranchHarmon_mute(harmon_mute *Harmon_mute)

func (*StageStruct) StageBranchHarmonic 

func (stage *StageStruct) StageBranchHarmonic(harmonic *Harmonic)

func (*StageStruct) StageBranchHarmony 

func (stage *StageStruct) StageBranchHarmony(harmony *Harmony)

func (*StageStruct) StageBranchHarmony_alter 

func (stage *StageStruct) StageBranchHarmony_alter(harmony_alter *Harmony_alter)

func (*StageStruct) StageBranchHarp_pedals 

func (stage *StageStruct) StageBranchHarp_pedals(harp_pedals *Harp_pedals)

func (*StageStruct) StageBranchHeel_toe 

func (stage *StageStruct) StageBranchHeel_toe(heel_toe *Heel_toe)

func (*StageStruct) StageBranchHole 

func (stage *StageStruct) StageBranchHole(hole *Hole)

func (*StageStruct) StageBranchHole_closed 

func (stage *StageStruct) StageBranchHole_closed(hole_closed *Hole_closed)

func (*StageStruct) StageBranchHorizontal_turn 

func (stage *StageStruct) StageBranchHorizontal_turn(horizontal_turn *Horizontal_turn)

func (*StageStruct) StageBranchIdentification 

func (stage *StageStruct) StageBranchIdentification(identification *Identification)

func (*StageStruct) StageBranchImage 

func (stage *StageStruct) StageBranchImage(image *Image)

func (*StageStruct) StageBranchInstrument 

func (stage *StageStruct) StageBranchInstrument(instrument *Instrument)

func (*StageStruct) StageBranchInstrument_change 

func (stage *StageStruct) StageBranchInstrument_change(instrument_change *Instrument_change)
func (stage *StageStruct) StageBranchInstrument_link(instrument_link *Instrument_link)

func (*StageStruct) StageBranchInterchangeable 

func (stage *StageStruct) StageBranchInterchangeable(interchangeable *Interchangeable)

func (*StageStruct) StageBranchInversion 

func (stage *StageStruct) StageBranchInversion(inversion *Inversion)

func (*StageStruct) StageBranchKey 

func (stage *StageStruct) StageBranchKey(key *Key)

func (*StageStruct) StageBranchKey_accidental 

func (stage *StageStruct) StageBranchKey_accidental(key_accidental *Key_accidental)

func (*StageStruct) StageBranchKey_octave 

func (stage *StageStruct) StageBranchKey_octave(key_octave *Key_octave)

func (*StageStruct) StageBranchKind 

func (stage *StageStruct) StageBranchKind(kind *Kind)

func (*StageStruct) StageBranchLevel 

func (stage *StageStruct) StageBranchLevel(level *Level)

func (*StageStruct) StageBranchLine_detail 

func (stage *StageStruct) StageBranchLine_detail(line_detail *Line_detail)

func (*StageStruct) StageBranchLine_width 

func (stage *StageStruct) StageBranchLine_width(line_width *Line_width)
func (stage *StageStruct) StageBranchLink(link *Link)

func (*StageStruct) StageBranchListen 

func (stage *StageStruct) StageBranchListen(listen *Listen)

func (*StageStruct) StageBranchListening 

func (stage *StageStruct) StageBranchListening(listening *Listening)

func (*StageStruct) StageBranchLyric 

func (stage *StageStruct) StageBranchLyric(lyric *Lyric)

func (*StageStruct) StageBranchLyric_font 

func (stage *StageStruct) StageBranchLyric_font(lyric_font *Lyric_font)

func (*StageStruct) StageBranchLyric_language 

func (stage *StageStruct) StageBranchLyric_language(lyric_language *Lyric_language)

func (*StageStruct) StageBranchMeasure_layout 

func (stage *StageStruct) StageBranchMeasure_layout(measure_layout *Measure_layout)

func (*StageStruct) StageBranchMeasure_numbering 

func (stage *StageStruct) StageBranchMeasure_numbering(measure_numbering *Measure_numbering)

func (*StageStruct) StageBranchMeasure_repeat 

func (stage *StageStruct) StageBranchMeasure_repeat(measure_repeat *Measure_repeat)

func (*StageStruct) StageBranchMeasure_style 

func (stage *StageStruct) StageBranchMeasure_style(measure_style *Measure_style)

func (*StageStruct) StageBranchMembrane 

func (stage *StageStruct) StageBranchMembrane(membrane *Membrane)

func (*StageStruct) StageBranchMetal 

func (stage *StageStruct) StageBranchMetal(metal *Metal)

func (*StageStruct) StageBranchMetronome 

func (stage *StageStruct) StageBranchMetronome(metronome *Metronome)

func (*StageStruct) StageBranchMetronome_beam 

func (stage *StageStruct) StageBranchMetronome_beam(metronome_beam *Metronome_beam)

func (*StageStruct) StageBranchMetronome_note 

func (stage *StageStruct) StageBranchMetronome_note(metronome_note *Metronome_note)

func (*StageStruct) StageBranchMetronome_tied 

func (stage *StageStruct) StageBranchMetronome_tied(metronome_tied *Metronome_tied)

func (*StageStruct) StageBranchMetronome_tuplet 

func (stage *StageStruct) StageBranchMetronome_tuplet(metronome_tuplet *Metronome_tuplet)

func (*StageStruct) StageBranchMidi_device 

func (stage *StageStruct) StageBranchMidi_device(midi_device *Midi_device)

func (*StageStruct) StageBranchMidi_instrument 

func (stage *StageStruct) StageBranchMidi_instrument(midi_instrument *Midi_instrument)

func (*StageStruct) StageBranchMiscellaneous 

func (stage *StageStruct) StageBranchMiscellaneous(miscellaneous *Miscellaneous)

func (*StageStruct) StageBranchMiscellaneous_field 

func (stage *StageStruct) StageBranchMiscellaneous_field(miscellaneous_field *Miscellaneous_field)

func (*StageStruct) StageBranchMordent 

func (stage *StageStruct) StageBranchMordent(mordent *Mordent)

func (*StageStruct) StageBranchMultiple_rest 

func (stage *StageStruct) StageBranchMultiple_rest(multiple_rest *Multiple_rest)

func (*StageStruct) StageBranchName_display 

func (stage *StageStruct) StageBranchName_display(name_display *Name_display)

func (*StageStruct) StageBranchNon_arpeggiate 

func (stage *StageStruct) StageBranchNon_arpeggiate(non_arpeggiate *Non_arpeggiate)

func (*StageStruct) StageBranchNotations 

func (stage *StageStruct) StageBranchNotations(notations *Notations)

func (*StageStruct) StageBranchNote 

func (stage *StageStruct) StageBranchNote(note *Note)

func (*StageStruct) StageBranchNote_size 

func (stage *StageStruct) StageBranchNote_size(note_size *Note_size)

func (*StageStruct) StageBranchNote_type 

func (stage *StageStruct) StageBranchNote_type(note_type *Note_type)

func (*StageStruct) StageBranchNotehead 

func (stage *StageStruct) StageBranchNotehead(notehead *Notehead)

func (*StageStruct) StageBranchNotehead_text 

func (stage *StageStruct) StageBranchNotehead_text(notehead_text *Notehead_text)

func (*StageStruct) StageBranchNumeral 

func (stage *StageStruct) StageBranchNumeral(numeral *Numeral)

func (*StageStruct) StageBranchNumeral_key 

func (stage *StageStruct) StageBranchNumeral_key(numeral_key *Numeral_key)

func (*StageStruct) StageBranchNumeral_root 

func (stage *StageStruct) StageBranchNumeral_root(numeral_root *Numeral_root)

func (*StageStruct) StageBranchOctave_shift 

func (stage *StageStruct) StageBranchOctave_shift(octave_shift *Octave_shift)

func (*StageStruct) StageBranchOffset 

func (stage *StageStruct) StageBranchOffset(offset *Offset)

func (*StageStruct) StageBranchOpus 

func (stage *StageStruct) StageBranchOpus(opus *Opus)

func (*StageStruct) StageBranchOrnaments 

func (stage *StageStruct) StageBranchOrnaments(ornaments *Ornaments)

func (*StageStruct) StageBranchOther_appearance 

func (stage *StageStruct) StageBranchOther_appearance(other_appearance *Other_appearance)

func (*StageStruct) StageBranchOther_listening 

func (stage *StageStruct) StageBranchOther_listening(other_listening *Other_listening)

func (*StageStruct) StageBranchOther_notation 

func (stage *StageStruct) StageBranchOther_notation(other_notation *Other_notation)

func (*StageStruct) StageBranchOther_play 

func (stage *StageStruct) StageBranchOther_play(other_play *Other_play)

func (*StageStruct) StageBranchPage_layout 

func (stage *StageStruct) StageBranchPage_layout(page_layout *Page_layout)

func (*StageStruct) StageBranchPage_margins 

func (stage *StageStruct) StageBranchPage_margins(page_margins *Page_margins)

func (*StageStruct) StageBranchPart_clef 

func (stage *StageStruct) StageBranchPart_clef(part_clef *Part_clef)

func (*StageStruct) StageBranchPart_group 

func (stage *StageStruct) StageBranchPart_group(part_group *Part_group)
func (stage *StageStruct) StageBranchPart_link(part_link *Part_link)

func (*StageStruct) StageBranchPart_list 

func (stage *StageStruct) StageBranchPart_list(part_list *Part_list)

func (*StageStruct) StageBranchPart_symbol 

func (stage *StageStruct) StageBranchPart_symbol(part_symbol *Part_symbol)

func (*StageStruct) StageBranchPart_transpose 

func (stage *StageStruct) StageBranchPart_transpose(part_transpose *Part_transpose)

func (*StageStruct) StageBranchPedal 

func (stage *StageStruct) StageBranchPedal(pedal *Pedal)

func (*StageStruct) StageBranchPedal_tuning 

func (stage *StageStruct) StageBranchPedal_tuning(pedal_tuning *Pedal_tuning)

func (*StageStruct) StageBranchPercussion 

func (stage *StageStruct) StageBranchPercussion(percussion *Percussion)

func (*StageStruct) StageBranchPitch 

func (stage *StageStruct) StageBranchPitch(pitch *Pitch)

func (*StageStruct) StageBranchPitched 

func (stage *StageStruct) StageBranchPitched(pitched *Pitched)

func (*StageStruct) StageBranchPlay 

func (stage *StageStruct) StageBranchPlay(play *Play)

func (*StageStruct) StageBranchPlayer 

func (stage *StageStruct) StageBranchPlayer(player *Player)

func (*StageStruct) StageBranchPrincipal_voice 

func (stage *StageStruct) StageBranchPrincipal_voice(principal_voice *Principal_voice)

func (*StageStruct) StageBranchPrint 

func (stage *StageStruct) StageBranchPrint(print *Print)

func (*StageStruct) StageBranchRelease 

func (stage *StageStruct) StageBranchRelease(release *Release)

func (*StageStruct) StageBranchRepeat 

func (stage *StageStruct) StageBranchRepeat(repeat *Repeat)

func (*StageStruct) StageBranchRest 

func (stage *StageStruct) StageBranchRest(rest *Rest)

func (*StageStruct) StageBranchRoot 

func (stage *StageStruct) StageBranchRoot(root *Root)

func (*StageStruct) StageBranchRoot_step 

func (stage *StageStruct) StageBranchRoot_step(root_step *Root_step)

func (*StageStruct) StageBranchScaling 

func (stage *StageStruct) StageBranchScaling(scaling *Scaling)

func (*StageStruct) StageBranchScordatura 

func (stage *StageStruct) StageBranchScordatura(scordatura *Scordatura)

func (*StageStruct) StageBranchScore_instrument 

func (stage *StageStruct) StageBranchScore_instrument(score_instrument *Score_instrument)

func (*StageStruct) StageBranchScore_part 

func (stage *StageStruct) StageBranchScore_part(score_part *Score_part)

func (*StageStruct) StageBranchScore_partwise 

func (stage *StageStruct) StageBranchScore_partwise(score_partwise *Score_partwise)

func (*StageStruct) StageBranchScore_timewise 

func (stage *StageStruct) StageBranchScore_timewise(score_timewise *Score_timewise)

func (*StageStruct) StageBranchSegno 

func (stage *StageStruct) StageBranchSegno(segno *Segno)

func (*StageStruct) StageBranchSlash 

func (stage *StageStruct) StageBranchSlash(slash *Slash)

func (*StageStruct) StageBranchSlide 

func (stage *StageStruct) StageBranchSlide(slide *Slide)

func (*StageStruct) StageBranchSlur 

func (stage *StageStruct) StageBranchSlur(slur *Slur)

func (*StageStruct) StageBranchSound 

func (stage *StageStruct) StageBranchSound(sound *Sound)

func (*StageStruct) StageBranchStaff_details 

func (stage *StageStruct) StageBranchStaff_details(staff_details *Staff_details)

func (*StageStruct) StageBranchStaff_divide 

func (stage *StageStruct) StageBranchStaff_divide(staff_divide *Staff_divide)

func (*StageStruct) StageBranchStaff_layout 

func (stage *StageStruct) StageBranchStaff_layout(staff_layout *Staff_layout)

func (*StageStruct) StageBranchStaff_size 

func (stage *StageStruct) StageBranchStaff_size(staff_size *Staff_size)

func (*StageStruct) StageBranchStaff_tuning 

func (stage *StageStruct) StageBranchStaff_tuning(staff_tuning *Staff_tuning)

func (*StageStruct) StageBranchStem 

func (stage *StageStruct) StageBranchStem(stem *Stem)

func (*StageStruct) StageBranchStick 

func (stage *StageStruct) StageBranchStick(stick *Stick)

func (*StageStruct) StageBranchString_mute 

func (stage *StageStruct) StageBranchString_mute(string_mute *String_mute)

func (*StageStruct) StageBranchStrong_accent 

func (stage *StageStruct) StageBranchStrong_accent(strong_accent *Strong_accent)

func (*StageStruct) StageBranchSupports 

func (stage *StageStruct) StageBranchSupports(supports *Supports)

func (*StageStruct) StageBranchSwing 

func (stage *StageStruct) StageBranchSwing(swing *Swing)

func (*StageStruct) StageBranchSync 

func (stage *StageStruct) StageBranchSync(sync *Sync)

func (*StageStruct) StageBranchSystem_dividers 

func (stage *StageStruct) StageBranchSystem_dividers(system_dividers *System_dividers)

func (*StageStruct) StageBranchSystem_layout 

func (stage *StageStruct) StageBranchSystem_layout(system_layout *System_layout)

func (*StageStruct) StageBranchSystem_margins 

func (stage *StageStruct) StageBranchSystem_margins(system_margins *System_margins)

func (*StageStruct) StageBranchTap 

func (stage *StageStruct) StageBranchTap(tap *Tap)

func (*StageStruct) StageBranchTechnical 

func (stage *StageStruct) StageBranchTechnical(technical *Technical)

func (*StageStruct) StageBranchText_element_data 

func (stage *StageStruct) StageBranchText_element_data(text_element_data *Text_element_data)

func (*StageStruct) StageBranchTie 

func (stage *StageStruct) StageBranchTie(tie *Tie)

func (*StageStruct) StageBranchTied 

func (stage *StageStruct) StageBranchTied(tied *Tied)

func (*StageStruct) StageBranchTime 

func (stage *StageStruct) StageBranchTime(time *Time)

func (*StageStruct) StageBranchTime_modification 

func (stage *StageStruct) StageBranchTime_modification(time_modification *Time_modification)

func (*StageStruct) StageBranchTimpani 

func (stage *StageStruct) StageBranchTimpani(timpani *Timpani)

func (*StageStruct) StageBranchTranspose 

func (stage *StageStruct) StageBranchTranspose(transpose *Transpose)

func (*StageStruct) StageBranchTremolo 

func (stage *StageStruct) StageBranchTremolo(tremolo *Tremolo)

func (*StageStruct) StageBranchTuplet 

func (stage *StageStruct) StageBranchTuplet(tuplet *Tuplet)

func (*StageStruct) StageBranchTuplet_dot 

func (stage *StageStruct) StageBranchTuplet_dot(tuplet_dot *Tuplet_dot)

func (*StageStruct) StageBranchTuplet_number 

func (stage *StageStruct) StageBranchTuplet_number(tuplet_number *Tuplet_number)

func (*StageStruct) StageBranchTuplet_portion 

func (stage *StageStruct) StageBranchTuplet_portion(tuplet_portion *Tuplet_portion)

func (*StageStruct) StageBranchTuplet_type 

func (stage *StageStruct) StageBranchTuplet_type(tuplet_type *Tuplet_type)

func (*StageStruct) StageBranchTyped_text 

func (stage *StageStruct) StageBranchTyped_text(typed_text *Typed_text)

func (*StageStruct) StageBranchUnpitched 

func (stage *StageStruct) StageBranchUnpitched(unpitched *Unpitched)

func (*StageStruct) StageBranchVirtual_instrument 

func (stage *StageStruct) StageBranchVirtual_instrument(virtual_instrument *Virtual_instrument)

func (*StageStruct) StageBranchWait 

func (stage *StageStruct) StageBranchWait(wait *Wait)

func (*StageStruct) StageBranchWavy_line 

func (stage *StageStruct) StageBranchWavy_line(wavy_line *Wavy_line)

func (*StageStruct) StageBranchWedge 

func (stage *StageStruct) StageBranchWedge(wedge *Wedge)

func (*StageStruct) StageBranchWood 

func (stage *StageStruct) StageBranchWood(wood *Wood)

func (*StageStruct) StageBranchWork 

func (stage *StageStruct) StageBranchWork(work *Work)

func (*StageStruct) Unstage 

func (stage *StageStruct) Unstage()

func (*StageStruct) UnstageBranchAccidental 

func (stage *StageStruct) UnstageBranchAccidental(accidental *Accidental)

insertion point for unstage branch per struct

func (*StageStruct) UnstageBranchAccidental_mark 

func (stage *StageStruct) UnstageBranchAccidental_mark(accidental_mark *Accidental_mark)

func (*StageStruct) UnstageBranchAccidental_text 

func (stage *StageStruct) UnstageBranchAccidental_text(accidental_text *Accidental_text)

func (*StageStruct) UnstageBranchAccord 

func (stage *StageStruct) UnstageBranchAccord(accord *Accord)

func (*StageStruct) UnstageBranchAccordion_registration 

func (stage *StageStruct) UnstageBranchAccordion_registration(accordion_registration *Accordion_registration)

func (*StageStruct) UnstageBranchAnyType 

func (stage *StageStruct) UnstageBranchAnyType(anytype *AnyType)

func (*StageStruct) UnstageBranchAppearance 

func (stage *StageStruct) UnstageBranchAppearance(appearance *Appearance)

func (*StageStruct) UnstageBranchArpeggiate 

func (stage *StageStruct) UnstageBranchArpeggiate(arpeggiate *Arpeggiate)

func (*StageStruct) UnstageBranchArrow 

func (stage *StageStruct) UnstageBranchArrow(arrow *Arrow)

func (*StageStruct) UnstageBranchArticulations 

func (stage *StageStruct) UnstageBranchArticulations(articulations *Articulations)

func (*StageStruct) UnstageBranchAssess 

func (stage *StageStruct) UnstageBranchAssess(assess *Assess)

func (*StageStruct) UnstageBranchAttributes 

func (stage *StageStruct) UnstageBranchAttributes(attributes *Attributes)

func (*StageStruct) UnstageBranchBackup 

func (stage *StageStruct) UnstageBranchBackup(backup *Backup)

func (*StageStruct) UnstageBranchBar_style_color 

func (stage *StageStruct) UnstageBranchBar_style_color(bar_style_color *Bar_style_color)

func (*StageStruct) UnstageBranchBarline 

func (stage *StageStruct) UnstageBranchBarline(barline *Barline)

func (*StageStruct) UnstageBranchBarre 

func (stage *StageStruct) UnstageBranchBarre(barre *Barre)

func (*StageStruct) UnstageBranchBass 

func (stage *StageStruct) UnstageBranchBass(bass *Bass)

func (*StageStruct) UnstageBranchBass_step 

func (stage *StageStruct) UnstageBranchBass_step(bass_step *Bass_step)

func (*StageStruct) UnstageBranchBeam 

func (stage *StageStruct) UnstageBranchBeam(beam *Beam)

func (*StageStruct) UnstageBranchBeat_repeat 

func (stage *StageStruct) UnstageBranchBeat_repeat(beat_repeat *Beat_repeat)

func (*StageStruct) UnstageBranchBeat_unit_tied 

func (stage *StageStruct) UnstageBranchBeat_unit_tied(beat_unit_tied *Beat_unit_tied)

func (*StageStruct) UnstageBranchBeater 

func (stage *StageStruct) UnstageBranchBeater(beater *Beater)

func (*StageStruct) UnstageBranchBend 

func (stage *StageStruct) UnstageBranchBend(bend *Bend)

func (*StageStruct) UnstageBranchBookmark 

func (stage *StageStruct) UnstageBranchBookmark(bookmark *Bookmark)

func (*StageStruct) UnstageBranchBracket 

func (stage *StageStruct) UnstageBranchBracket(bracket *Bracket)

func (*StageStruct) UnstageBranchBreath_mark 

func (stage *StageStruct) UnstageBranchBreath_mark(breath_mark *Breath_mark)

func (*StageStruct) UnstageBranchCaesura 

func (stage *StageStruct) UnstageBranchCaesura(caesura *Caesura)

func (*StageStruct) UnstageBranchCancel 

func (stage *StageStruct) UnstageBranchCancel(cancel *Cancel)

func (*StageStruct) UnstageBranchClef 

func (stage *StageStruct) UnstageBranchClef(clef *Clef)

func (*StageStruct) UnstageBranchCoda 

func (stage *StageStruct) UnstageBranchCoda(coda *Coda)

func (*StageStruct) UnstageBranchCredit 

func (stage *StageStruct) UnstageBranchCredit(credit *Credit)

func (*StageStruct) UnstageBranchDashes 

func (stage *StageStruct) UnstageBranchDashes(dashes *Dashes)

func (*StageStruct) UnstageBranchDefaults 

func (stage *StageStruct) UnstageBranchDefaults(defaults *Defaults)

func (*StageStruct) UnstageBranchDegree 

func (stage *StageStruct) UnstageBranchDegree(degree *Degree)

func (*StageStruct) UnstageBranchDegree_alter 

func (stage *StageStruct) UnstageBranchDegree_alter(degree_alter *Degree_alter)

func (*StageStruct) UnstageBranchDegree_type 

func (stage *StageStruct) UnstageBranchDegree_type(degree_type *Degree_type)

func (*StageStruct) UnstageBranchDegree_value 

func (stage *StageStruct) UnstageBranchDegree_value(degree_value *Degree_value)

func (*StageStruct) UnstageBranchDirection 

func (stage *StageStruct) UnstageBranchDirection(direction *Direction)

func (*StageStruct) UnstageBranchDirection_type 

func (stage *StageStruct) UnstageBranchDirection_type(direction_type *Direction_type)

func (*StageStruct) UnstageBranchDistance 

func (stage *StageStruct) UnstageBranchDistance(distance *Distance)

func (*StageStruct) UnstageBranchDouble 

func (stage *StageStruct) UnstageBranchDouble(double *Double)

func (*StageStruct) UnstageBranchDynamics 

func (stage *StageStruct) UnstageBranchDynamics(dynamics *Dynamics)

func (*StageStruct) UnstageBranchEffect 

func (stage *StageStruct) UnstageBranchEffect(effect *Effect)

func (*StageStruct) UnstageBranchElision 

func (stage *StageStruct) UnstageBranchElision(elision *Elision)

func (*StageStruct) UnstageBranchEmpty 

func (stage *StageStruct) UnstageBranchEmpty(empty *Empty)

func (*StageStruct) UnstageBranchEmpty_font 

func (stage *StageStruct) UnstageBranchEmpty_font(empty_font *Empty_font)

func (*StageStruct) UnstageBranchEmpty_line 

func (stage *StageStruct) UnstageBranchEmpty_line(empty_line *Empty_line)

func (*StageStruct) UnstageBranchEmpty_placement 

func (stage *StageStruct) UnstageBranchEmpty_placement(empty_placement *Empty_placement)

func (*StageStruct) UnstageBranchEmpty_placement_smufl 

func (stage *StageStruct) UnstageBranchEmpty_placement_smufl(empty_placement_smufl *Empty_placement_smufl)

func (*StageStruct) UnstageBranchEmpty_print_object_style_align 

func (stage *StageStruct) UnstageBranchEmpty_print_object_style_align(empty_print_object_style_align *Empty_print_object_style_align)

func (*StageStruct) UnstageBranchEmpty_print_style 

func (stage *StageStruct) UnstageBranchEmpty_print_style(empty_print_style *Empty_print_style)

func (*StageStruct) UnstageBranchEmpty_print_style_align 

func (stage *StageStruct) UnstageBranchEmpty_print_style_align(empty_print_style_align *Empty_print_style_align)

func (*StageStruct) UnstageBranchEmpty_print_style_align_id 

func (stage *StageStruct) UnstageBranchEmpty_print_style_align_id(empty_print_style_align_id *Empty_print_style_align_id)

func (*StageStruct) UnstageBranchEmpty_trill_sound 

func (stage *StageStruct) UnstageBranchEmpty_trill_sound(empty_trill_sound *Empty_trill_sound)

func (*StageStruct) UnstageBranchEncoding 

func (stage *StageStruct) UnstageBranchEncoding(encoding *Encoding)

func (*StageStruct) UnstageBranchEnding 

func (stage *StageStruct) UnstageBranchEnding(ending *Ending)

func (*StageStruct) UnstageBranchExtend 

func (stage *StageStruct) UnstageBranchExtend(extend *Extend)

func (*StageStruct) UnstageBranchFeature 

func (stage *StageStruct) UnstageBranchFeature(feature *Feature)

func (*StageStruct) UnstageBranchFermata 

func (stage *StageStruct) UnstageBranchFermata(fermata *Fermata)

func (*StageStruct) UnstageBranchFigure 

func (stage *StageStruct) UnstageBranchFigure(figure *Figure)

func (*StageStruct) UnstageBranchFigured_bass 

func (stage *StageStruct) UnstageBranchFigured_bass(figured_bass *Figured_bass)

func (*StageStruct) UnstageBranchFingering 

func (stage *StageStruct) UnstageBranchFingering(fingering *Fingering)

func (*StageStruct) UnstageBranchFirst_fret 

func (stage *StageStruct) UnstageBranchFirst_fret(first_fret *First_fret)

func (*StageStruct) UnstageBranchFoo 

func (stage *StageStruct) UnstageBranchFoo(foo *Foo)

func (*StageStruct) UnstageBranchFor_part 

func (stage *StageStruct) UnstageBranchFor_part(for_part *For_part)

func (*StageStruct) UnstageBranchFormatted_symbol 

func (stage *StageStruct) UnstageBranchFormatted_symbol(formatted_symbol *Formatted_symbol)

func (*StageStruct) UnstageBranchFormatted_symbol_id 

func (stage *StageStruct) UnstageBranchFormatted_symbol_id(formatted_symbol_id *Formatted_symbol_id)

func (*StageStruct) UnstageBranchForward 

func (stage *StageStruct) UnstageBranchForward(forward *Forward)

func (*StageStruct) UnstageBranchFrame 

func (stage *StageStruct) UnstageBranchFrame(frame *Frame)

func (*StageStruct) UnstageBranchFrame_note 

func (stage *StageStruct) UnstageBranchFrame_note(frame_note *Frame_note)

func (*StageStruct) UnstageBranchFret 

func (stage *StageStruct) UnstageBranchFret(fret *Fret)

func (*StageStruct) UnstageBranchGlass 

func (stage *StageStruct) UnstageBranchGlass(glass *Glass)

func (*StageStruct) UnstageBranchGlissando 

func (stage *StageStruct) UnstageBranchGlissando(glissando *Glissando)

func (*StageStruct) UnstageBranchGlyph 

func (stage *StageStruct) UnstageBranchGlyph(glyph *Glyph)

func (*StageStruct) UnstageBranchGrace 

func (stage *StageStruct) UnstageBranchGrace(grace *Grace)

func (*StageStruct) UnstageBranchGroup_barline 

func (stage *StageStruct) UnstageBranchGroup_barline(group_barline *Group_barline)

func (*StageStruct) UnstageBranchGroup_symbol 

func (stage *StageStruct) UnstageBranchGroup_symbol(group_symbol *Group_symbol)

func (*StageStruct) UnstageBranchGrouping 

func (stage *StageStruct) UnstageBranchGrouping(grouping *Grouping)

func (*StageStruct) UnstageBranchHammer_on_pull_off 

func (stage *StageStruct) UnstageBranchHammer_on_pull_off(hammer_on_pull_off *Hammer_on_pull_off)

func (*StageStruct) UnstageBranchHandbell 

func (stage *StageStruct) UnstageBranchHandbell(handbell *Handbell)

func (*StageStruct) UnstageBranchHarmon_closed 

func (stage *StageStruct) UnstageBranchHarmon_closed(harmon_closed *Harmon_closed)

func (*StageStruct) UnstageBranchHarmon_mute 

func (stage *StageStruct) UnstageBranchHarmon_mute(harmon_mute *Harmon_mute)

func (*StageStruct) UnstageBranchHarmonic 

func (stage *StageStruct) UnstageBranchHarmonic(harmonic *Harmonic)

func (*StageStruct) UnstageBranchHarmony 

func (stage *StageStruct) UnstageBranchHarmony(harmony *Harmony)

func (*StageStruct) UnstageBranchHarmony_alter 

func (stage *StageStruct) UnstageBranchHarmony_alter(harmony_alter *Harmony_alter)

func (*StageStruct) UnstageBranchHarp_pedals 

func (stage *StageStruct) UnstageBranchHarp_pedals(harp_pedals *Harp_pedals)

func (*StageStruct) UnstageBranchHeel_toe 

func (stage *StageStruct) UnstageBranchHeel_toe(heel_toe *Heel_toe)

func (*StageStruct) UnstageBranchHole 

func (stage *StageStruct) UnstageBranchHole(hole *Hole)

func (*StageStruct) UnstageBranchHole_closed 

func (stage *StageStruct) UnstageBranchHole_closed(hole_closed *Hole_closed)

func (*StageStruct) UnstageBranchHorizontal_turn 

func (stage *StageStruct) UnstageBranchHorizontal_turn(horizontal_turn *Horizontal_turn)

func (*StageStruct) UnstageBranchIdentification 

func (stage *StageStruct) UnstageBranchIdentification(identification *Identification)

func (*StageStruct) UnstageBranchImage 

func (stage *StageStruct) UnstageBranchImage(image *Image)

func (*StageStruct) UnstageBranchInstrument 

func (stage *StageStruct) UnstageBranchInstrument(instrument *Instrument)

func (*StageStruct) UnstageBranchInstrument_change 

func (stage *StageStruct) UnstageBranchInstrument_change(instrument_change *Instrument_change)
func (stage *StageStruct) UnstageBranchInstrument_link(instrument_link *Instrument_link)

func (*StageStruct) UnstageBranchInterchangeable 

func (stage *StageStruct) UnstageBranchInterchangeable(interchangeable *Interchangeable)

func (*StageStruct) UnstageBranchInversion 

func (stage *StageStruct) UnstageBranchInversion(inversion *Inversion)

func (*StageStruct) UnstageBranchKey 

func (stage *StageStruct) UnstageBranchKey(key *Key)

func (*StageStruct) UnstageBranchKey_accidental 

func (stage *StageStruct) UnstageBranchKey_accidental(key_accidental *Key_accidental)

func (*StageStruct) UnstageBranchKey_octave 

func (stage *StageStruct) UnstageBranchKey_octave(key_octave *Key_octave)

func (*StageStruct) UnstageBranchKind 

func (stage *StageStruct) UnstageBranchKind(kind *Kind)

func (*StageStruct) UnstageBranchLevel 

func (stage *StageStruct) UnstageBranchLevel(level *Level)

func (*StageStruct) UnstageBranchLine_detail 

func (stage *StageStruct) UnstageBranchLine_detail(line_detail *Line_detail)

func (*StageStruct) UnstageBranchLine_width 

func (stage *StageStruct) UnstageBranchLine_width(line_width *Line_width)
func (stage *StageStruct) UnstageBranchLink(link *Link)

func (*StageStruct) UnstageBranchListen 

func (stage *StageStruct) UnstageBranchListen(listen *Listen)

func (*StageStruct) UnstageBranchListening 

func (stage *StageStruct) UnstageBranchListening(listening *Listening)

func (*StageStruct) UnstageBranchLyric 

func (stage *StageStruct) UnstageBranchLyric(lyric *Lyric)

func (*StageStruct) UnstageBranchLyric_font 

func (stage *StageStruct) UnstageBranchLyric_font(lyric_font *Lyric_font)

func (*StageStruct) UnstageBranchLyric_language 

func (stage *StageStruct) UnstageBranchLyric_language(lyric_language *Lyric_language)

func (*StageStruct) UnstageBranchMeasure_layout 

func (stage *StageStruct) UnstageBranchMeasure_layout(measure_layout *Measure_layout)

func (*StageStruct) UnstageBranchMeasure_numbering 

func (stage *StageStruct) UnstageBranchMeasure_numbering(measure_numbering *Measure_numbering)

func (*StageStruct) UnstageBranchMeasure_repeat 

func (stage *StageStruct) UnstageBranchMeasure_repeat(measure_repeat *Measure_repeat)

func (*StageStruct) UnstageBranchMeasure_style 

func (stage *StageStruct) UnstageBranchMeasure_style(measure_style *Measure_style)

func (*StageStruct) UnstageBranchMembrane 

func (stage *StageStruct) UnstageBranchMembrane(membrane *Membrane)

func (*StageStruct) UnstageBranchMetal 

func (stage *StageStruct) UnstageBranchMetal(metal *Metal)

func (*StageStruct) UnstageBranchMetronome 

func (stage *StageStruct) UnstageBranchMetronome(metronome *Metronome)

func (*StageStruct) UnstageBranchMetronome_beam 

func (stage *StageStruct) UnstageBranchMetronome_beam(metronome_beam *Metronome_beam)

func (*StageStruct) UnstageBranchMetronome_note 

func (stage *StageStruct) UnstageBranchMetronome_note(metronome_note *Metronome_note)

func (*StageStruct) UnstageBranchMetronome_tied 

func (stage *StageStruct) UnstageBranchMetronome_tied(metronome_tied *Metronome_tied)

func (*StageStruct) UnstageBranchMetronome_tuplet 

func (stage *StageStruct) UnstageBranchMetronome_tuplet(metronome_tuplet *Metronome_tuplet)

func (*StageStruct) UnstageBranchMidi_device 

func (stage *StageStruct) UnstageBranchMidi_device(midi_device *Midi_device)

func (*StageStruct) UnstageBranchMidi_instrument 

func (stage *StageStruct) UnstageBranchMidi_instrument(midi_instrument *Midi_instrument)

func (*StageStruct) UnstageBranchMiscellaneous 

func (stage *StageStruct) UnstageBranchMiscellaneous(miscellaneous *Miscellaneous)

func (*StageStruct) UnstageBranchMiscellaneous_field 

func (stage *StageStruct) UnstageBranchMiscellaneous_field(miscellaneous_field *Miscellaneous_field)

func (*StageStruct) UnstageBranchMordent 

func (stage *StageStruct) UnstageBranchMordent(mordent *Mordent)

func (*StageStruct) UnstageBranchMultiple_rest 

func (stage *StageStruct) UnstageBranchMultiple_rest(multiple_rest *Multiple_rest)

func (*StageStruct) UnstageBranchName_display 

func (stage *StageStruct) UnstageBranchName_display(name_display *Name_display)

func (*StageStruct) UnstageBranchNon_arpeggiate 

func (stage *StageStruct) UnstageBranchNon_arpeggiate(non_arpeggiate *Non_arpeggiate)

func (*StageStruct) UnstageBranchNotations 

func (stage *StageStruct) UnstageBranchNotations(notations *Notations)

func (*StageStruct) UnstageBranchNote 

func (stage *StageStruct) UnstageBranchNote(note *Note)

func (*StageStruct) UnstageBranchNote_size 

func (stage *StageStruct) UnstageBranchNote_size(note_size *Note_size)

func (*StageStruct) UnstageBranchNote_type 

func (stage *StageStruct) UnstageBranchNote_type(note_type *Note_type)

func (*StageStruct) UnstageBranchNotehead 

func (stage *StageStruct) UnstageBranchNotehead(notehead *Notehead)

func (*StageStruct) UnstageBranchNotehead_text 

func (stage *StageStruct) UnstageBranchNotehead_text(notehead_text *Notehead_text)

func (*StageStruct) UnstageBranchNumeral 

func (stage *StageStruct) UnstageBranchNumeral(numeral *Numeral)

func (*StageStruct) UnstageBranchNumeral_key 

func (stage *StageStruct) UnstageBranchNumeral_key(numeral_key *Numeral_key)

func (*StageStruct) UnstageBranchNumeral_root 

func (stage *StageStruct) UnstageBranchNumeral_root(numeral_root *Numeral_root)

func (*StageStruct) UnstageBranchOctave_shift 

func (stage *StageStruct) UnstageBranchOctave_shift(octave_shift *Octave_shift)

func (*StageStruct) UnstageBranchOffset 

func (stage *StageStruct) UnstageBranchOffset(offset *Offset)

func (*StageStruct) UnstageBranchOpus 

func (stage *StageStruct) UnstageBranchOpus(opus *Opus)

func (*StageStruct) UnstageBranchOrnaments 

func (stage *StageStruct) UnstageBranchOrnaments(ornaments *Ornaments)

func (*StageStruct) UnstageBranchOther_appearance 

func (stage *StageStruct) UnstageBranchOther_appearance(other_appearance *Other_appearance)

func (*StageStruct) UnstageBranchOther_listening 

func (stage *StageStruct) UnstageBranchOther_listening(other_listening *Other_listening)

func (*StageStruct) UnstageBranchOther_notation 

func (stage *StageStruct) UnstageBranchOther_notation(other_notation *Other_notation)

func (*StageStruct) UnstageBranchOther_play 

func (stage *StageStruct) UnstageBranchOther_play(other_play *Other_play)

func (*StageStruct) UnstageBranchPage_layout 

func (stage *StageStruct) UnstageBranchPage_layout(page_layout *Page_layout)

func (*StageStruct) UnstageBranchPage_margins 

func (stage *StageStruct) UnstageBranchPage_margins(page_margins *Page_margins)

func (*StageStruct) UnstageBranchPart_clef 

func (stage *StageStruct) UnstageBranchPart_clef(part_clef *Part_clef)

func (*StageStruct) UnstageBranchPart_group 

func (stage *StageStruct) UnstageBranchPart_group(part_group *Part_group)
func (stage *StageStruct) UnstageBranchPart_link(part_link *Part_link)

func (*StageStruct) UnstageBranchPart_list 

func (stage *StageStruct) UnstageBranchPart_list(part_list *Part_list)

func (*StageStruct) UnstageBranchPart_symbol 

func (stage *StageStruct) UnstageBranchPart_symbol(part_symbol *Part_symbol)

func (*StageStruct) UnstageBranchPart_transpose 

func (stage *StageStruct) UnstageBranchPart_transpose(part_transpose *Part_transpose)

func (*StageStruct) UnstageBranchPedal 

func (stage *StageStruct) UnstageBranchPedal(pedal *Pedal)

func (*StageStruct) UnstageBranchPedal_tuning 

func (stage *StageStruct) UnstageBranchPedal_tuning(pedal_tuning *Pedal_tuning)

func (*StageStruct) UnstageBranchPercussion 

func (stage *StageStruct) UnstageBranchPercussion(percussion *Percussion)

func (*StageStruct) UnstageBranchPitch 

func (stage *StageStruct) UnstageBranchPitch(pitch *Pitch)

func (*StageStruct) UnstageBranchPitched 

func (stage *StageStruct) UnstageBranchPitched(pitched *Pitched)

func (*StageStruct) UnstageBranchPlay 

func (stage *StageStruct) UnstageBranchPlay(play *Play)

func (*StageStruct) UnstageBranchPlayer 

func (stage *StageStruct) UnstageBranchPlayer(player *Player)

func (*StageStruct) UnstageBranchPrincipal_voice 

func (stage *StageStruct) UnstageBranchPrincipal_voice(principal_voice *Principal_voice)

func (*StageStruct) UnstageBranchPrint 

func (stage *StageStruct) UnstageBranchPrint(print *Print)

func (*StageStruct) UnstageBranchRelease 

func (stage *StageStruct) UnstageBranchRelease(release *Release)

func (*StageStruct) UnstageBranchRepeat 

func (stage *StageStruct) UnstageBranchRepeat(repeat *Repeat)

func (*StageStruct) UnstageBranchRest 

func (stage *StageStruct) UnstageBranchRest(rest *Rest)

func (*StageStruct) UnstageBranchRoot 

func (stage *StageStruct) UnstageBranchRoot(root *Root)

func (*StageStruct) UnstageBranchRoot_step 

func (stage *StageStruct) UnstageBranchRoot_step(root_step *Root_step)

func (*StageStruct) UnstageBranchScaling 

func (stage *StageStruct) UnstageBranchScaling(scaling *Scaling)

func (*StageStruct) UnstageBranchScordatura 

func (stage *StageStruct) UnstageBranchScordatura(scordatura *Scordatura)

func (*StageStruct) UnstageBranchScore_instrument 

func (stage *StageStruct) UnstageBranchScore_instrument(score_instrument *Score_instrument)

func (*StageStruct) UnstageBranchScore_part 

func (stage *StageStruct) UnstageBranchScore_part(score_part *Score_part)

func (*StageStruct) UnstageBranchScore_partwise 

func (stage *StageStruct) UnstageBranchScore_partwise(score_partwise *Score_partwise)

func (*StageStruct) UnstageBranchScore_timewise 

func (stage *StageStruct) UnstageBranchScore_timewise(score_timewise *Score_timewise)

func (*StageStruct) UnstageBranchSegno 

func (stage *StageStruct) UnstageBranchSegno(segno *Segno)

func (*StageStruct) UnstageBranchSlash 

func (stage *StageStruct) UnstageBranchSlash(slash *Slash)

func (*StageStruct) UnstageBranchSlide 

func (stage *StageStruct) UnstageBranchSlide(slide *Slide)

func (*StageStruct) UnstageBranchSlur 

func (stage *StageStruct) UnstageBranchSlur(slur *Slur)

func (*StageStruct) UnstageBranchSound 

func (stage *StageStruct) UnstageBranchSound(sound *Sound)

func (*StageStruct) UnstageBranchStaff_details 

func (stage *StageStruct) UnstageBranchStaff_details(staff_details *Staff_details)

func (*StageStruct) UnstageBranchStaff_divide 

func (stage *StageStruct) UnstageBranchStaff_divide(staff_divide *Staff_divide)

func (*StageStruct) UnstageBranchStaff_layout 

func (stage *StageStruct) UnstageBranchStaff_layout(staff_layout *Staff_layout)

func (*StageStruct) UnstageBranchStaff_size 

func (stage *StageStruct) UnstageBranchStaff_size(staff_size *Staff_size)

func (*StageStruct) UnstageBranchStaff_tuning 

func (stage *StageStruct) UnstageBranchStaff_tuning(staff_tuning *Staff_tuning)

func (*StageStruct) UnstageBranchStem 

func (stage *StageStruct) UnstageBranchStem(stem *Stem)

func (*StageStruct) UnstageBranchStick 

func (stage *StageStruct) UnstageBranchStick(stick *Stick)

func (*StageStruct) UnstageBranchString_mute 

func (stage *StageStruct) UnstageBranchString_mute(string_mute *String_mute)

func (*StageStruct) UnstageBranchStrong_accent 

func (stage *StageStruct) UnstageBranchStrong_accent(strong_accent *Strong_accent)

func (*StageStruct) UnstageBranchSupports 

func (stage *StageStruct) UnstageBranchSupports(supports *Supports)

func (*StageStruct) UnstageBranchSwing 

func (stage *StageStruct) UnstageBranchSwing(swing *Swing)

func (*StageStruct) UnstageBranchSync 

func (stage *StageStruct) UnstageBranchSync(sync *Sync)

func (*StageStruct) UnstageBranchSystem_dividers 

func (stage *StageStruct) UnstageBranchSystem_dividers(system_dividers *System_dividers)

func (*StageStruct) UnstageBranchSystem_layout 

func (stage *StageStruct) UnstageBranchSystem_layout(system_layout *System_layout)

func (*StageStruct) UnstageBranchSystem_margins 

func (stage *StageStruct) UnstageBranchSystem_margins(system_margins *System_margins)

func (*StageStruct) UnstageBranchTap 

func (stage *StageStruct) UnstageBranchTap(tap *Tap)

func (*StageStruct) UnstageBranchTechnical 

func (stage *StageStruct) UnstageBranchTechnical(technical *Technical)

func (*StageStruct) UnstageBranchText_element_data 

func (stage *StageStruct) UnstageBranchText_element_data(text_element_data *Text_element_data)

func (*StageStruct) UnstageBranchTie 

func (stage *StageStruct) UnstageBranchTie(tie *Tie)

func (*StageStruct) UnstageBranchTied 

func (stage *StageStruct) UnstageBranchTied(tied *Tied)

func (*StageStruct) UnstageBranchTime 

func (stage *StageStruct) UnstageBranchTime(time *Time)

func (*StageStruct) UnstageBranchTime_modification 

func (stage *StageStruct) UnstageBranchTime_modification(time_modification *Time_modification)

func (*StageStruct) UnstageBranchTimpani 

func (stage *StageStruct) UnstageBranchTimpani(timpani *Timpani)

func (*StageStruct) UnstageBranchTranspose 

func (stage *StageStruct) UnstageBranchTranspose(transpose *Transpose)

func (*StageStruct) UnstageBranchTremolo 

func (stage *StageStruct) UnstageBranchTremolo(tremolo *Tremolo)

func (*StageStruct) UnstageBranchTuplet 

func (stage *StageStruct) UnstageBranchTuplet(tuplet *Tuplet)

func (*StageStruct) UnstageBranchTuplet_dot 

func (stage *StageStruct) UnstageBranchTuplet_dot(tuplet_dot *Tuplet_dot)

func (*StageStruct) UnstageBranchTuplet_number 

func (stage *StageStruct) UnstageBranchTuplet_number(tuplet_number *Tuplet_number)

func (*StageStruct) UnstageBranchTuplet_portion 

func (stage *StageStruct) UnstageBranchTuplet_portion(tuplet_portion *Tuplet_portion)

func (*StageStruct) UnstageBranchTuplet_type 

func (stage *StageStruct) UnstageBranchTuplet_type(tuplet_type *Tuplet_type)

func (*StageStruct) UnstageBranchTyped_text 

func (stage *StageStruct) UnstageBranchTyped_text(typed_text *Typed_text)

func (*StageStruct) UnstageBranchUnpitched 

func (stage *StageStruct) UnstageBranchUnpitched(unpitched *Unpitched)

func (*StageStruct) UnstageBranchVirtual_instrument 

func (stage *StageStruct) UnstageBranchVirtual_instrument(virtual_instrument *Virtual_instrument)

func (*StageStruct) UnstageBranchWait 

func (stage *StageStruct) UnstageBranchWait(wait *Wait)

func (*StageStruct) UnstageBranchWavy_line 

func (stage *StageStruct) UnstageBranchWavy_line(wavy_line *Wavy_line)

func (*StageStruct) UnstageBranchWedge 

func (stage *StageStruct) UnstageBranchWedge(wedge *Wedge)

func (*StageStruct) UnstageBranchWood 

func (stage *StageStruct) UnstageBranchWood(wood *Wood)

func (*StageStruct) UnstageBranchWork 

func (stage *StageStruct) UnstageBranchWork(work *Work)

type Start_note 

type Start_note string
const (
	Start_noteUpper Start_note = "upper"

	Start_noteMain Start_note = "main"

	Start_noteBelow Start_note = "below"
)

func (Start_note) CodeValues 

func (start_note Start_note) CodeValues() (res []string)

func (Start_note) Codes 

func (start_note Start_note) Codes() (res []string)

func (*Start_note) FromCodeString 

func (start_note *Start_note) FromCodeString(input string) (err error)

func (*Start_note) FromString 

func (start_note *Start_note) FromString(input string) (err error)

func (*Start_note) ToCodeString 

func (start_note *Start_note) ToCodeString() (res string)

func (Start_note) ToString 

func (start_note Start_note) ToString() (res string)

Utility function for Start_note if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Start_stop 

type Start_stop string
const (
	Start_stopStart Start_stop = "start"

	Start_stopStop Start_stop = "stop"
)

func (Start_stop) CodeValues 

func (start_stop Start_stop) CodeValues() (res []string)

func (Start_stop) Codes 

func (start_stop Start_stop) Codes() (res []string)

func (*Start_stop) FromCodeString 

func (start_stop *Start_stop) FromCodeString(input string) (err error)

func (*Start_stop) FromString 

func (start_stop *Start_stop) FromString(input string) (err error)

func (*Start_stop) ToCodeString 

func (start_stop *Start_stop) ToCodeString() (res string)

func (Start_stop) ToString 

func (start_stop Start_stop) ToString() (res string)

Utility function for Start_stop if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Start_stop_change_continue 

type Start_stop_change_continue string
const (
	Start_stop_change_continueStart Start_stop_change_continue = "start"

	Start_stop_change_continueStop Start_stop_change_continue = "stop"

	Start_stop_change_continueChange Start_stop_change_continue = "change"

	Start_stop_change_continueContinue_ Start_stop_change_continue = "continue"
)

func (Start_stop_change_continue) CodeValues 

func (start_stop_change_continue Start_stop_change_continue) CodeValues() (res []string)

func (Start_stop_change_continue) Codes 

func (start_stop_change_continue Start_stop_change_continue) Codes() (res []string)

func (*Start_stop_change_continue) FromCodeString 

func (start_stop_change_continue *Start_stop_change_continue) FromCodeString(input string) (err error)

func (*Start_stop_change_continue) FromString 

func (start_stop_change_continue *Start_stop_change_continue) FromString(input string) (err error)

func (*Start_stop_change_continue) ToCodeString 

func (start_stop_change_continue *Start_stop_change_continue) ToCodeString() (res string)

func (Start_stop_change_continue) ToString 

func (start_stop_change_continue Start_stop_change_continue) ToString() (res string)

Utility function for Start_stop_change_continue if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Start_stop_continue 

type Start_stop_continue string
const (
	Start_stop_continueStart Start_stop_continue = "start"

	Start_stop_continueStop Start_stop_continue = "stop"

	Start_stop_continueContinue_ Start_stop_continue = "continue"
)

func (Start_stop_continue) CodeValues 

func (start_stop_continue Start_stop_continue) CodeValues() (res []string)

func (Start_stop_continue) Codes 

func (start_stop_continue Start_stop_continue) Codes() (res []string)

func (*Start_stop_continue) FromCodeString 

func (start_stop_continue *Start_stop_continue) FromCodeString(input string) (err error)

func (*Start_stop_continue) FromString 

func (start_stop_continue *Start_stop_continue) FromString(input string) (err error)

func (*Start_stop_continue) ToCodeString 

func (start_stop_continue *Start_stop_continue) ToCodeString() (res string)

func (Start_stop_continue) ToString 

func (start_stop_continue Start_stop_continue) ToString() (res string)

Utility function for Start_stop_continue if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Start_stop_discontinue 

type Start_stop_discontinue string
const (
	Start_stop_discontinueStart Start_stop_discontinue = "start"

	Start_stop_discontinueStop Start_stop_discontinue = "stop"

	Start_stop_discontinueDiscontinue Start_stop_discontinue = "discontinue"
)

func (Start_stop_discontinue) CodeValues 

func (start_stop_discontinue Start_stop_discontinue) CodeValues() (res []string)

func (Start_stop_discontinue) Codes 

func (start_stop_discontinue Start_stop_discontinue) Codes() (res []string)

func (*Start_stop_discontinue) FromCodeString 

func (start_stop_discontinue *Start_stop_discontinue) FromCodeString(input string) (err error)

func (*Start_stop_discontinue) FromString 

func (start_stop_discontinue *Start_stop_discontinue) FromString(input string) (err error)

func (*Start_stop_discontinue) ToCodeString 

func (start_stop_discontinue *Start_stop_discontinue) ToCodeString() (res string)

func (Start_stop_discontinue) ToString 

func (start_stop_discontinue Start_stop_discontinue) ToString() (res string)

Utility function for Start_stop_discontinue if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Start_stop_single 

type Start_stop_single string
const (
	Start_stop_singleStart Start_stop_single = "start"

	Start_stop_singleStop Start_stop_single = "stop"

	Start_stop_singleSingle Start_stop_single = "single"
)

func (Start_stop_single) CodeValues 

func (start_stop_single Start_stop_single) CodeValues() (res []string)

func (Start_stop_single) Codes 

func (start_stop_single Start_stop_single) Codes() (res []string)

func (*Start_stop_single) FromCodeString 

func (start_stop_single *Start_stop_single) FromCodeString(input string) (err error)

func (*Start_stop_single) FromString 

func (start_stop_single *Start_stop_single) FromString(input string) (err error)

func (*Start_stop_single) ToCodeString 

func (start_stop_single *Start_stop_single) ToCodeString() (res string)

func (Start_stop_single) ToString 

func (start_stop_single Start_stop_single) ToString() (res string)

Utility function for Start_stop_single if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Stem 

type Stem struct {
	Name  string
	Value *Stem_value `xml:",chardata" json:"-,"`
}

func CopyBranchStem 

func CopyBranchStem(mapOrigCopy map[any]any, stemFrom *Stem) (stemTo *Stem)

func (*Stem) Checkout 

func (stem *Stem) Checkout(stage *StageStruct) *Stem

Checkout stem to the back repo (if it is already staged)

func (*Stem) Commit 

func (stem *Stem) Commit(stage *StageStruct) *Stem

commit stem to the back repo (if it is already staged)

func (*Stem) CommitVoid 

func (stem *Stem) CommitVoid(stage *StageStruct)

func (*Stem) CopyBasicFields 

func (from *Stem) CopyBasicFields(to *Stem)

func (*Stem) GetName 

func (stem *Stem) GetName() (res string)

for satisfaction of GongStruct interface

func (*Stem) Stage 

func (stem *Stem) Stage(stage *StageStruct) *Stem

Stage puts stem to the model stage

func (*Stem) Unstage 

func (stem *Stem) Unstage(stage *StageStruct) *Stem

Unstage removes stem off the model stage

func (*Stem) UnstageVoid 

func (stem *Stem) UnstageVoid(stage *StageStruct)

UnstageVoid removes stem off the model stage

type Stem_WOP 

type Stem_WOP struct {
	// insertion point
	Name string
}

type Stem_value 

type Stem_value string
const (
	Stem_valueDown Stem_value = "down"

	Stem_valueUp Stem_value = "up"

	Stem_valueDouble Stem_value = "double"

	Stem_valueNone Stem_value = "none"
)

func (Stem_value) CodeValues 

func (stem_value Stem_value) CodeValues() (res []string)

func (Stem_value) Codes 

func (stem_value Stem_value) Codes() (res []string)

func (*Stem_value) FromCodeString 

func (stem_value *Stem_value) FromCodeString(input string) (err error)

func (*Stem_value) FromString 

func (stem_value *Stem_value) FromString(input string) (err error)

func (*Stem_value) ToCodeString 

func (stem_value *Stem_value) ToCodeString() (res string)

func (Stem_value) ToString 

func (stem_value Stem_value) ToString() (res string)

Utility function for Stem_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Step 

type Step string
const (
	StepA Step = "A"

	StepB Step = "B"

	StepC Step = "C"

	StepD Step = "D"

	StepE Step = "E"

	StepF Step = "F"

	StepG Step = "G"
)

func (Step) CodeValues 

func (step Step) CodeValues() (res []string)

func (Step) Codes 

func (step Step) Codes() (res []string)

func (*Step) FromCodeString 

func (step *Step) FromCodeString(input string) (err error)

func (*Step) FromString 

func (step *Step) FromString(input string) (err error)

func (*Step) ToCodeString 

func (step *Step) ToCodeString() (res string)

func (Step) ToString 

func (step Step) ToString() (res string)

Utility function for Step if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Stick 

type Stick struct {
	Name       string
	Stick_type *Stick_type `xml:"stick-type,omitempty" json:"stick-type,omitempty"`

	Stick_material *Stick_material `xml:"stick-material,omitempty" json:"stick-material,omitempty"`

	Tip *Tip_direction `xml:"tip,attr,omitempty" json:"tip,omitempty"`

	Parentheses *Yes_no `xml:"parentheses,attr,omitempty" json:"parentheses,omitempty"`

	Dashed_circle *Yes_no `xml:"dashed-circle,attr,omitempty" json:"dashed-circle,omitempty"`
}

func CopyBranchStick 

func CopyBranchStick(mapOrigCopy map[any]any, stickFrom *Stick) (stickTo *Stick)

func (*Stick) Checkout 

func (stick *Stick) Checkout(stage *StageStruct) *Stick

Checkout stick to the back repo (if it is already staged)

func (*Stick) Commit 

func (stick *Stick) Commit(stage *StageStruct) *Stick

commit stick to the back repo (if it is already staged)

func (*Stick) CommitVoid 

func (stick *Stick) CommitVoid(stage *StageStruct)

func (*Stick) CopyBasicFields 

func (from *Stick) CopyBasicFields(to *Stick)

func (*Stick) GetName 

func (stick *Stick) GetName() (res string)

for satisfaction of GongStruct interface

func (*Stick) Stage 

func (stick *Stick) Stage(stage *StageStruct) *Stick

Stage puts stick to the model stage

func (*Stick) Unstage 

func (stick *Stick) Unstage(stage *StageStruct) *Stick

Unstage removes stick off the model stage

func (*Stick) UnstageVoid 

func (stick *Stick) UnstageVoid(stage *StageStruct)

UnstageVoid removes stick off the model stage

type Stick_WOP 

type Stick_WOP struct {
	// insertion point
	Name string
}

type Stick_location 

type Stick_location string
const (
	Stick_locationCenter Stick_location = "center"

	Stick_locationRim Stick_location = "rim"

	Stick_locationCymbalbell Stick_location = "cymbal bell"

	Stick_locationCymbaledge Stick_location = "cymbal edge"
)

func (Stick_location) CodeValues 

func (stick_location Stick_location) CodeValues() (res []string)

func (Stick_location) Codes 

func (stick_location Stick_location) Codes() (res []string)

func (*Stick_location) FromCodeString 

func (stick_location *Stick_location) FromCodeString(input string) (err error)

func (*Stick_location) FromString 

func (stick_location *Stick_location) FromString(input string) (err error)

func (*Stick_location) ToCodeString 

func (stick_location *Stick_location) ToCodeString() (res string)

func (Stick_location) ToString 

func (stick_location Stick_location) ToString() (res string)

Utility function for Stick_location if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Stick_material 

type Stick_material string
const (
	Stick_materialSoft Stick_material = "soft"

	Stick_materialMedium Stick_material = "medium"

	Stick_materialHard Stick_material = "hard"

	Stick_materialShaded Stick_material = "shaded"

	Stick_materialX Stick_material = "x"
)

func (Stick_material) CodeValues 

func (stick_material Stick_material) CodeValues() (res []string)

func (Stick_material) Codes 

func (stick_material Stick_material) Codes() (res []string)

func (*Stick_material) FromCodeString 

func (stick_material *Stick_material) FromCodeString(input string) (err error)

func (*Stick_material) FromString 

func (stick_material *Stick_material) FromString(input string) (err error)

func (*Stick_material) ToCodeString 

func (stick_material *Stick_material) ToCodeString() (res string)

func (Stick_material) ToString 

func (stick_material Stick_material) ToString() (res string)

Utility function for Stick_material if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Stick_type 

type Stick_type string
const (
	Stick_typeBassdrum Stick_type = "bass drum"

	Stick_typeDoublebassdrum Stick_type = "double bass drum"

	Stick_typeGlockenspiel Stick_type = "glockenspiel"

	Stick_typeGum Stick_type = "gum"

	Stick_typeHammer Stick_type = "hammer"

	Stick_typeSuperball Stick_type = "superball"

	Stick_typeTimpani Stick_type = "timpani"

	Stick_typeWound Stick_type = "wound"

	Stick_typeXylophone Stick_type = "xylophone"

	Stick_typeYarn Stick_type = "yarn"
)

func (Stick_type) CodeValues 

func (stick_type Stick_type) CodeValues() (res []string)

func (Stick_type) Codes 

func (stick_type Stick_type) Codes() (res []string)

func (*Stick_type) FromCodeString 

func (stick_type *Stick_type) FromCodeString(input string) (err error)

func (*Stick_type) FromString 

func (stick_type *Stick_type) FromString(input string) (err error)

func (*Stick_type) ToCodeString 

func (stick_type *Stick_type) ToCodeString() (res string)

func (Stick_type) ToString 

func (stick_type Stick_type) ToString() (res string)

Utility function for Stick_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type String_mute 

type String_mute struct {
	Name string
	Type *On_off `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchString_mute 

func CopyBranchString_mute(mapOrigCopy map[any]any, string_muteFrom *String_mute) (string_muteTo *String_mute)

func (*String_mute) Checkout 

func (string_mute *String_mute) Checkout(stage *StageStruct) *String_mute

Checkout string_mute to the back repo (if it is already staged)

func (*String_mute) Commit 

func (string_mute *String_mute) Commit(stage *StageStruct) *String_mute

commit string_mute to the back repo (if it is already staged)

func (*String_mute) CommitVoid 

func (string_mute *String_mute) CommitVoid(stage *StageStruct)

func (*String_mute) CopyBasicFields 

func (from *String_mute) CopyBasicFields(to *String_mute)

func (*String_mute) GetName 

func (string_mute *String_mute) GetName() (res string)

for satisfaction of GongStruct interface

func (*String_mute) Stage 

func (string_mute *String_mute) Stage(stage *StageStruct) *String_mute

Stage puts string_mute to the model stage

func (*String_mute) Unstage 

func (string_mute *String_mute) Unstage(stage *StageStruct) *String_mute

Unstage removes string_mute off the model stage

func (*String_mute) UnstageVoid 

func (string_mute *String_mute) UnstageVoid(stage *StageStruct)

UnstageVoid removes string_mute off the model stage

type String_mute_WOP 

type String_mute_WOP struct {
	// insertion point
	Name string
}

type String_number 

type String_number PositiveInteger

type Strong_accent 

type Strong_accent struct {
	Name string
	*Empty_placement

	Type *Up_down `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchStrong_accent 

func CopyBranchStrong_accent(mapOrigCopy map[any]any, strong_accentFrom *Strong_accent) (strong_accentTo *Strong_accent)

func (*Strong_accent) Checkout 

func (strong_accent *Strong_accent) Checkout(stage *StageStruct) *Strong_accent

Checkout strong_accent to the back repo (if it is already staged)

func (*Strong_accent) Commit 

func (strong_accent *Strong_accent) Commit(stage *StageStruct) *Strong_accent

commit strong_accent to the back repo (if it is already staged)

func (*Strong_accent) CommitVoid 

func (strong_accent *Strong_accent) CommitVoid(stage *StageStruct)

func (*Strong_accent) CopyBasicFields 

func (from *Strong_accent) CopyBasicFields(to *Strong_accent)

func (*Strong_accent) GetName 

func (strong_accent *Strong_accent) GetName() (res string)

for satisfaction of GongStruct interface

func (*Strong_accent) Stage 

func (strong_accent *Strong_accent) Stage(stage *StageStruct) *Strong_accent

Stage puts strong_accent to the model stage

func (*Strong_accent) Unstage 

func (strong_accent *Strong_accent) Unstage(stage *StageStruct) *Strong_accent

Unstage removes strong_accent off the model stage

func (*Strong_accent) UnstageVoid 

func (strong_accent *Strong_accent) UnstageVoid(stage *StageStruct)

UnstageVoid removes strong_accent off the model stage

type Strong_accent_WOP 

type Strong_accent_WOP struct {
	// insertion point
	Name string
}

type Style_text 

type Style_text string

func (Style_text) CodeValues 

func (style_text Style_text) CodeValues() (res []string)

func (Style_text) Codes 

func (style_text Style_text) Codes() (res []string)

func (*Style_text) FromCodeString 

func (style_text *Style_text) FromCodeString(input string) (err error)

func (*Style_text) FromString 

func (style_text *Style_text) FromString(input string) (err error)

func (*Style_text) ToCodeString 

func (style_text *Style_text) ToCodeString() (res string)

func (Style_text) ToString 

func (style_text Style_text) ToString() (res string)

Utility function for Style_text if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Supports 

type Supports struct {
	Name string
	Type *Yes_no `xml:"type,attr,omitempty" json:"type,omitempty"`

	Element *NMTOKEN `xml:"element,attr,omitempty" json:"element,omitempty"`

	Attribute *NMTOKEN `xml:"attribute,attr,omitempty" json:"attribute,omitempty"`

	Value string `xml:"value,attr,omitempty" json:"value,omitempty"`
}

func CopyBranchSupports 

func CopyBranchSupports(mapOrigCopy map[any]any, supportsFrom *Supports) (supportsTo *Supports)

func (*Supports) Checkout 

func (supports *Supports) Checkout(stage *StageStruct) *Supports

Checkout supports to the back repo (if it is already staged)

func (*Supports) Commit 

func (supports *Supports) Commit(stage *StageStruct) *Supports

commit supports to the back repo (if it is already staged)

func (*Supports) CommitVoid 

func (supports *Supports) CommitVoid(stage *StageStruct)

func (*Supports) CopyBasicFields 

func (from *Supports) CopyBasicFields(to *Supports)

func (*Supports) GetName 

func (supports *Supports) GetName() (res string)

for satisfaction of GongStruct interface

func (*Supports) Stage 

func (supports *Supports) Stage(stage *StageStruct) *Supports

Stage puts supports to the model stage

func (*Supports) Unstage 

func (supports *Supports) Unstage(stage *StageStruct) *Supports

Unstage removes supports off the model stage

func (*Supports) UnstageVoid 

func (supports *Supports) UnstageVoid(stage *StageStruct)

UnstageVoid removes supports off the model stage

type Supports_WOP 

type Supports_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Swing 

type Swing struct {
	Name        string
	Swing_style string `xml:"swing-style,omitempty" json:"swing-style,omitempty"`

	Straight *Empty `xml:"straight,omitempty" json:"straight,omitempty"`
}

func CopyBranchSwing 

func CopyBranchSwing(mapOrigCopy map[any]any, swingFrom *Swing) (swingTo *Swing)

func (*Swing) Checkout 

func (swing *Swing) Checkout(stage *StageStruct) *Swing

Checkout swing to the back repo (if it is already staged)

func (*Swing) Commit 

func (swing *Swing) Commit(stage *StageStruct) *Swing

commit swing to the back repo (if it is already staged)

func (*Swing) CommitVoid 

func (swing *Swing) CommitVoid(stage *StageStruct)

func (*Swing) CopyBasicFields 

func (from *Swing) CopyBasicFields(to *Swing)

func (*Swing) GetName 

func (swing *Swing) GetName() (res string)

for satisfaction of GongStruct interface

func (*Swing) Stage 

func (swing *Swing) Stage(stage *StageStruct) *Swing

Stage puts swing to the model stage

func (*Swing) Unstage 

func (swing *Swing) Unstage(stage *StageStruct) *Swing

Unstage removes swing off the model stage

func (*Swing) UnstageVoid 

func (swing *Swing) UnstageVoid(stage *StageStruct)

UnstageVoid removes swing off the model stage

type Swing_WOP 

type Swing_WOP struct {
	// insertion point
	Name        string
	Swing_style string
}

type Swing_type_value 

type Swing_type_value Note_type_value
const (
	Swing_type_value16th Swing_type_value = "16th"

	Swing_type_valueEighth Swing_type_value = "eighth"
)

type Syllabic 

type Syllabic string
const (
	SyllabicSingle Syllabic = "single"

	SyllabicBegin Syllabic = "begin"

	SyllabicEnd Syllabic = "end"

	SyllabicMiddle Syllabic = "middle"
)

func (Syllabic) CodeValues 

func (syllabic Syllabic) CodeValues() (res []string)

func (Syllabic) Codes 

func (syllabic Syllabic) Codes() (res []string)

func (*Syllabic) FromCodeString 

func (syllabic *Syllabic) FromCodeString(input string) (err error)

func (*Syllabic) FromString 

func (syllabic *Syllabic) FromString(input string) (err error)

func (*Syllabic) ToCodeString 

func (syllabic *Syllabic) ToCodeString() (res string)

func (Syllabic) ToString 

func (syllabic Syllabic) ToString() (res string)

Utility function for Syllabic if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Symbol_size 

type Symbol_size string
const (
	Symbol_sizeFull Symbol_size = "full"

	Symbol_sizeCue Symbol_size = "cue"

	Symbol_sizeGrace_cue Symbol_size = "grace-cue"

	Symbol_sizeLarge Symbol_size = "large"
)

func (Symbol_size) CodeValues 

func (symbol_size Symbol_size) CodeValues() (res []string)

func (Symbol_size) Codes 

func (symbol_size Symbol_size) Codes() (res []string)

func (*Symbol_size) FromCodeString 

func (symbol_size *Symbol_size) FromCodeString(input string) (err error)

func (*Symbol_size) FromString 

func (symbol_size *Symbol_size) FromString(input string) (err error)

func (*Symbol_size) ToCodeString 

func (symbol_size *Symbol_size) ToCodeString() (res string)

func (Symbol_size) ToString 

func (symbol_size Symbol_size) ToString() (res string)

Utility function for Symbol_size if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Sync 

type Sync struct {
	Name string
	Type *Sync_type `xml:"type,attr,omitempty" json:"type,omitempty"`

	Latency *Milliseconds `xml:"latency,attr,omitempty" json:"latency,omitempty"`

	Player *IDREF `xml:"player,attr,omitempty" json:"player,omitempty"`

	Time_only *Time_only `xml:"time-only,attr,omitempty" json:"time-only,omitempty"`
}

func CopyBranchSync 

func CopyBranchSync(mapOrigCopy map[any]any, syncFrom *Sync) (syncTo *Sync)

func (*Sync) Checkout 

func (sync *Sync) Checkout(stage *StageStruct) *Sync

Checkout sync to the back repo (if it is already staged)

func (*Sync) Commit 

func (sync *Sync) Commit(stage *StageStruct) *Sync

commit sync to the back repo (if it is already staged)

func (*Sync) CommitVoid 

func (sync *Sync) CommitVoid(stage *StageStruct)

func (*Sync) CopyBasicFields 

func (from *Sync) CopyBasicFields(to *Sync)

func (*Sync) GetName 

func (sync *Sync) GetName() (res string)

for satisfaction of GongStruct interface

func (*Sync) Stage 

func (sync *Sync) Stage(stage *StageStruct) *Sync

Stage puts sync to the model stage

func (*Sync) Unstage 

func (sync *Sync) Unstage(stage *StageStruct) *Sync

Unstage removes sync off the model stage

func (*Sync) UnstageVoid 

func (sync *Sync) UnstageVoid(stage *StageStruct)

UnstageVoid removes sync off the model stage

type Sync_WOP 

type Sync_WOP struct {
	// insertion point
	Name string
}

type Sync_type 

type Sync_type string
const (
	Sync_typeNone Sync_type = "none"

	Sync_typeTempo Sync_type = "tempo"

	Sync_typeMostly_tempo Sync_type = "mostly-tempo"

	Sync_typeMostly_event Sync_type = "mostly-event"

	Sync_typeEvent Sync_type = "event"

	Sync_typeAlways_event Sync_type = "always-event"
)

func (Sync_type) CodeValues 

func (sync_type Sync_type) CodeValues() (res []string)

func (Sync_type) Codes 

func (sync_type Sync_type) Codes() (res []string)

func (*Sync_type) FromCodeString 

func (sync_type *Sync_type) FromCodeString(input string) (err error)

func (*Sync_type) FromString 

func (sync_type *Sync_type) FromString(input string) (err error)

func (*Sync_type) ToCodeString 

func (sync_type *Sync_type) ToCodeString() (res string)

func (Sync_type) ToString 

func (sync_type Sync_type) ToString() (res string)

Utility function for Sync_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type System_dividers 

type System_dividers struct {
	Name         string
	Left_divider *Empty_print_object_style_align `xml:"left-divider,omitempty" json:"left-divider,omitempty"`

	Right_divider *Empty_print_object_style_align `xml:"right-divider,omitempty" json:"right-divider,omitempty"`
}

func CopyBranchSystem_dividers 

func CopyBranchSystem_dividers(mapOrigCopy map[any]any, system_dividersFrom *System_dividers) (system_dividersTo *System_dividers)

func (*System_dividers) Checkout 

func (system_dividers *System_dividers) Checkout(stage *StageStruct) *System_dividers

Checkout system_dividers to the back repo (if it is already staged)

func (*System_dividers) Commit 

func (system_dividers *System_dividers) Commit(stage *StageStruct) *System_dividers

commit system_dividers to the back repo (if it is already staged)

func (*System_dividers) CommitVoid 

func (system_dividers *System_dividers) CommitVoid(stage *StageStruct)

func (*System_dividers) CopyBasicFields 

func (from *System_dividers) CopyBasicFields(to *System_dividers)

func (*System_dividers) GetName 

func (system_dividers *System_dividers) GetName() (res string)

for satisfaction of GongStruct interface

func (*System_dividers) Stage 

func (system_dividers *System_dividers) Stage(stage *StageStruct) *System_dividers

Stage puts system_dividers to the model stage

func (*System_dividers) Unstage 

func (system_dividers *System_dividers) Unstage(stage *StageStruct) *System_dividers

Unstage removes system_dividers off the model stage

func (*System_dividers) UnstageVoid 

func (system_dividers *System_dividers) UnstageVoid(stage *StageStruct)

UnstageVoid removes system_dividers off the model stage

type System_dividers_WOP 

type System_dividers_WOP struct {
	// insertion point
	Name string
}

type System_layout 

type System_layout struct {
	Name           string
	System_margins *System_margins `xml:"system-margins,omitempty" json:"system-margins,omitempty"`

	System_distance *Tenths `xml:"system-distance,omitempty" json:"system-distance,omitempty"`

	Top_system_distance *Tenths `xml:"top-system-distance,omitempty" json:"top-system-distance,omitempty"`

	System_dividers *System_dividers `xml:"system-dividers,omitempty" json:"system-dividers,omitempty"`
}

func CopyBranchSystem_layout 

func CopyBranchSystem_layout(mapOrigCopy map[any]any, system_layoutFrom *System_layout) (system_layoutTo *System_layout)

func (*System_layout) Checkout 

func (system_layout *System_layout) Checkout(stage *StageStruct) *System_layout

Checkout system_layout to the back repo (if it is already staged)

func (*System_layout) Commit 

func (system_layout *System_layout) Commit(stage *StageStruct) *System_layout

commit system_layout to the back repo (if it is already staged)

func (*System_layout) CommitVoid 

func (system_layout *System_layout) CommitVoid(stage *StageStruct)

func (*System_layout) CopyBasicFields 

func (from *System_layout) CopyBasicFields(to *System_layout)

func (*System_layout) GetName 

func (system_layout *System_layout) GetName() (res string)

for satisfaction of GongStruct interface

func (*System_layout) Stage 

func (system_layout *System_layout) Stage(stage *StageStruct) *System_layout

Stage puts system_layout to the model stage

func (*System_layout) Unstage 

func (system_layout *System_layout) Unstage(stage *StageStruct) *System_layout

Unstage removes system_layout off the model stage

func (*System_layout) UnstageVoid 

func (system_layout *System_layout) UnstageVoid(stage *StageStruct)

UnstageVoid removes system_layout off the model stage

type System_layout_WOP 

type System_layout_WOP struct {
	// insertion point
	Name string
}

type System_margins 

type System_margins struct {
	Name string
}

func CopyBranchSystem_margins 

func CopyBranchSystem_margins(mapOrigCopy map[any]any, system_marginsFrom *System_margins) (system_marginsTo *System_margins)

func (*System_margins) Checkout 

func (system_margins *System_margins) Checkout(stage *StageStruct) *System_margins

Checkout system_margins to the back repo (if it is already staged)

func (*System_margins) Commit 

func (system_margins *System_margins) Commit(stage *StageStruct) *System_margins

commit system_margins to the back repo (if it is already staged)

func (*System_margins) CommitVoid 

func (system_margins *System_margins) CommitVoid(stage *StageStruct)

func (*System_margins) CopyBasicFields 

func (from *System_margins) CopyBasicFields(to *System_margins)

func (*System_margins) GetName 

func (system_margins *System_margins) GetName() (res string)

for satisfaction of GongStruct interface

func (*System_margins) Stage 

func (system_margins *System_margins) Stage(stage *StageStruct) *System_margins

Stage puts system_margins to the model stage

func (*System_margins) Unstage 

func (system_margins *System_margins) Unstage(stage *StageStruct) *System_margins

Unstage removes system_margins off the model stage

func (*System_margins) UnstageVoid 

func (system_margins *System_margins) UnstageVoid(stage *StageStruct)

UnstageVoid removes system_margins off the model stage

type System_margins_WOP 

type System_margins_WOP struct {
	// insertion point
	Name string
}

type System_relation 

type System_relation System_relation_number
const (
	System_relationOnly_top System_relation = "only-top"

	System_relationAlso_top System_relation = "also-top"

	System_relationNone System_relation = "none"
)

type System_relation_number 

type System_relation_number string
const (
	System_relation_numberOnly_top System_relation_number = "only-top"

	System_relation_numberOnly_bottom System_relation_number = "only-bottom"

	System_relation_numberAlso_top System_relation_number = "also-top"

	System_relation_numberAlso_bottom System_relation_number = "also-bottom"

	System_relation_numberNone System_relation_number = "none"
)

func (System_relation_number) CodeValues 

func (system_relation_number System_relation_number) CodeValues() (res []string)

func (System_relation_number) Codes 

func (system_relation_number System_relation_number) Codes() (res []string)

func (*System_relation_number) FromCodeString 

func (system_relation_number *System_relation_number) FromCodeString(input string) (err error)

func (*System_relation_number) FromString 

func (system_relation_number *System_relation_number) FromString(input string) (err error)

func (*System_relation_number) ToCodeString 

func (system_relation_number *System_relation_number) ToCodeString() (res string)

func (System_relation_number) ToString 

func (system_relation_number System_relation_number) ToString() (res string)

Utility function for System_relation_number if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Tabulator 

type Tabulator interface {
	AddSheet(sheetName string)
	AddRow(sheetName string) int
	AddCell(sheetName string, rowId, columnIndex int, value string)
}

Tabulator is an interface for writing to a table strings

type Tap 

type Tap struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Hand *Tap_hand `xml:"hand,attr,omitempty" json:"hand,omitempty"`
}

func CopyBranchTap 

func CopyBranchTap(mapOrigCopy map[any]any, tapFrom *Tap) (tapTo *Tap)

func (*Tap) Checkout 

func (tap *Tap) Checkout(stage *StageStruct) *Tap

Checkout tap to the back repo (if it is already staged)

func (*Tap) Commit 

func (tap *Tap) Commit(stage *StageStruct) *Tap

commit tap to the back repo (if it is already staged)

func (*Tap) CommitVoid 

func (tap *Tap) CommitVoid(stage *StageStruct)

func (*Tap) CopyBasicFields 

func (from *Tap) CopyBasicFields(to *Tap)

func (*Tap) GetName 

func (tap *Tap) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tap) Stage 

func (tap *Tap) Stage(stage *StageStruct) *Tap

Stage puts tap to the model stage

func (*Tap) Unstage 

func (tap *Tap) Unstage(stage *StageStruct) *Tap

Unstage removes tap off the model stage

func (*Tap) UnstageVoid 

func (tap *Tap) UnstageVoid(stage *StageStruct)

UnstageVoid removes tap off the model stage

type Tap_WOP 

type Tap_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Tap_hand 

type Tap_hand string
const (
	Tap_handLeft Tap_hand = "left"

	Tap_handRight Tap_hand = "right"
)

func (Tap_hand) CodeValues 

func (tap_hand Tap_hand) CodeValues() (res []string)

func (Tap_hand) Codes 

func (tap_hand Tap_hand) Codes() (res []string)

func (*Tap_hand) FromCodeString 

func (tap_hand *Tap_hand) FromCodeString(input string) (err error)

func (*Tap_hand) FromString 

func (tap_hand *Tap_hand) FromString(input string) (err error)

func (*Tap_hand) ToCodeString 

func (tap_hand *Tap_hand) ToCodeString() (res string)

func (Tap_hand) ToString 

func (tap_hand Tap_hand) ToString() (res string)

Utility function for Tap_hand if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Technical 

type Technical struct {
	Name string

	// The up-bow element represents the symbol that is used both for
	// up-bowing on bowed instruments, and up-stroke on plucked instruments.
	Up_bow *Empty_placement `xml:"up-bow,omitempty" json:"up-bow,omitempty"`

	// The down-bow element represents the symbol that is used both
	// for down-bowing on bowed instruments, and down-stroke on plucked
	// instruments.
	Down_bow *Empty_placement `xml:"down-bow,omitempty" json:"down-bow,omitempty"`

	Harmonic *Harmonic `xml:"harmonic,omitempty" json:"harmonic,omitempty"`

	// The open-string element represents the zero-shaped open string
	// symbol.
	Open_string *Empty_placement `xml:"open-string,omitempty" json:"open-string,omitempty"`

	// The thumb-position element represents the thumb position
	// symbol. This is a circle with a line, where the line does not come within
	// the circle. It is distinct from the snap pizzicato symbol, where the line
	// comes inside the circle.
	Thumb_position *Empty_placement `xml:"thumb-position,omitempty" json:"thumb-position,omitempty"`

	Fingering *Fingering `xml:"fingering,omitempty" json:"fingering,omitempty"`

	// The pluck element is used to specify the plucking fingering on
	// a fretted instrument, where the fingering element refers to the fretting
	// fingering. Typical values are p, i, m, a for pulgar/thumb, indicio/index,
	// medio/middle, and anular/ring fingers.
	Pluck *Placement_text `xml:"pluck,omitempty" json:"pluck,omitempty"`

	// The double-tongue element represents the double tongue symbol
	// (two dots arranged horizontally).
	Double_tongue *Empty_placement `xml:"double-tongue,omitempty" json:"double-tongue,omitempty"`

	// The triple-tongue element represents the triple tongue symbol
	// (three dots arranged horizontally).
	Triple_tongue *Empty_placement `xml:"triple-tongue,omitempty" json:"triple-tongue,omitempty"`

	// The stopped element represents the stopped symbol, which looks
	// like a plus sign. The smufl attribute distinguishes different SMuFL glyphs
	// that have a similar appearance such as handbellsMalletBellSuspended and
	// guitarClosePedal. If not present, the default glyph is brassMuteClosed.
	Stopped *Empty_placement_smufl `xml:"stopped,omitempty" json:"stopped,omitempty"`

	// The snap-pizzicato element represents the snap pizzicato
	// symbol. This is a circle with a line, where the line comes inside the
	// circle. It is distinct from the thumb-position symbol, where the line does
	// not come inside the circle.
	Snap_pizzicato *Empty_placement `xml:"snap-pizzicato,omitempty" json:"snap-pizzicato,omitempty"`

	Fret *Fret `xml:"fret,omitempty" json:"fret,omitempty"`

	Astring string `xml:"string,omitempty" json:"string,omitempty"`

	Hammer_on *Hammer_on_pull_off `xml:"hammer-on,omitempty" json:"hammer-on,omitempty"`

	Pull_off *Hammer_on_pull_off `xml:"pull-off,omitempty" json:"pull-off,omitempty"`

	Bend *Bend `xml:"bend,omitempty" json:"bend,omitempty"`

	Tap *Tap `xml:"tap,omitempty" json:"tap,omitempty"`

	Heel *Heel_toe `xml:"heel,omitempty" json:"heel,omitempty"`

	Toe *Heel_toe `xml:"toe,omitempty" json:"toe,omitempty"`

	// The fingernails element is used in notation for harp and other
	// plucked string instruments.
	Fingernails *Empty_placement `xml:"fingernails,omitempty" json:"fingernails,omitempty"`

	Hole *Hole `xml:"hole,omitempty" json:"hole,omitempty"`

	Arrow *Arrow `xml:"arrow,omitempty" json:"arrow,omitempty"`

	Handbell *Handbell `xml:"handbell,omitempty" json:"handbell,omitempty"`

	// The brass-bend element represents the u-shaped bend symbol
	// used in brass notation, distinct from the bend element used in guitar music.
	Brass_bend *Empty_placement `xml:"brass-bend,omitempty" json:"brass-bend,omitempty"`

	// The flip element represents the flip symbol used in brass
	// notation.
	Flip *Empty_placement `xml:"flip,omitempty" json:"flip,omitempty"`

	// The smear element represents the tilde-shaped smear symbol
	// used in brass notation.
	Smear *Empty_placement `xml:"smear,omitempty" json:"smear,omitempty"`

	// The open element represents the open symbol, which looks like
	// a circle. The smufl attribute can be used to distinguish different SMuFL
	// glyphs that have a similar appearance such as brassMuteOpen and
	// guitarOpenPedal. If not present, the default glyph is brassMuteOpen.
	Open *Empty_placement_smufl `xml:"open,omitempty" json:"open,omitempty"`

	// The half-muted element represents the half-muted symbol, which
	// looks like a circle with a plus sign inside. The smufl attribute can be used
	// to distinguish different SMuFL glyphs that have a similar appearance such as
	// brassMuteHalfClosed and guitarHalfOpenPedal. If not present, the default
	// glyph is brassMuteHalfClosed.
	Half_muted *Empty_placement_smufl `xml:"half-muted,omitempty" json:"half-muted,omitempty"`

	Harmon_mute *Harmon_mute `xml:"harmon-mute,omitempty" json:"harmon-mute,omitempty"`

	// The golpe element represents the golpe symbol that is used for
	// tapping the pick guard in guitar music.
	Golpe *Empty_placement `xml:"golpe,omitempty" json:"golpe,omitempty"`

	// The other-technical element is used to define any technical
	// indications not yet in the MusicXML format. The smufl attribute can be used
	// to specify a particular glyph, allowing application interoperability without
	// requiring every SMuFL technical indication to have a MusicXML element
	// equivalent. Using the other-technical element without the smufl attribute
	// allows for extended representation, though without application
	// interoperability.
	Other_technical *Other_placement_text `xml:"other-technical,omitempty" json:"other-technical,omitempty"`
}

func CopyBranchTechnical 

func CopyBranchTechnical(mapOrigCopy map[any]any, technicalFrom *Technical) (technicalTo *Technical)

func (*Technical) Checkout 

func (technical *Technical) Checkout(stage *StageStruct) *Technical

Checkout technical to the back repo (if it is already staged)

func (*Technical) Commit 

func (technical *Technical) Commit(stage *StageStruct) *Technical

commit technical to the back repo (if it is already staged)

func (*Technical) CommitVoid 

func (technical *Technical) CommitVoid(stage *StageStruct)

func (*Technical) CopyBasicFields 

func (from *Technical) CopyBasicFields(to *Technical)

func (*Technical) GetName 

func (technical *Technical) GetName() (res string)

for satisfaction of GongStruct interface

func (*Technical) Stage 

func (technical *Technical) Stage(stage *StageStruct) *Technical

Stage puts technical to the model stage

func (*Technical) Unstage 

func (technical *Technical) Unstage(stage *StageStruct) *Technical

Unstage removes technical off the model stage

func (*Technical) UnstageVoid 

func (technical *Technical) UnstageVoid(stage *StageStruct)

UnstageVoid removes technical off the model stage

type Technical_WOP 

type Technical_WOP struct {
	// insertion point
	Name    string
	Astring string
}

type Tenths 

type Tenths float64

type Text_direction 

type Text_direction string
const (
	Text_directionLtr Text_direction = "ltr"

	Text_directionRtl Text_direction = "rtl"

	Text_directionLro Text_direction = "lro"

	Text_directionRlo Text_direction = "rlo"
)

func (Text_direction) CodeValues 

func (text_direction Text_direction) CodeValues() (res []string)

func (Text_direction) Codes 

func (text_direction Text_direction) Codes() (res []string)

func (*Text_direction) FromCodeString 

func (text_direction *Text_direction) FromCodeString(input string) (err error)

func (*Text_direction) FromString 

func (text_direction *Text_direction) FromString(input string) (err error)

func (*Text_direction) ToCodeString 

func (text_direction *Text_direction) ToCodeString() (res string)

func (Text_direction) ToString 

func (text_direction Text_direction) ToString() (res string)

Utility function for Text_direction if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Text_element_data 

type Text_element_data struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	EmptyString string `xml:",attr,omitempty" json:",omitempty"`
}

func CopyBranchText_element_data 

func CopyBranchText_element_data(mapOrigCopy map[any]any, text_element_dataFrom *Text_element_data) (text_element_dataTo *Text_element_data)

func (*Text_element_data) Checkout 

func (text_element_data *Text_element_data) Checkout(stage *StageStruct) *Text_element_data

Checkout text_element_data to the back repo (if it is already staged)

func (*Text_element_data) Commit 

func (text_element_data *Text_element_data) Commit(stage *StageStruct) *Text_element_data

commit text_element_data to the back repo (if it is already staged)

func (*Text_element_data) CommitVoid 

func (text_element_data *Text_element_data) CommitVoid(stage *StageStruct)

func (*Text_element_data) CopyBasicFields 

func (from *Text_element_data) CopyBasicFields(to *Text_element_data)

func (*Text_element_data) GetName 

func (text_element_data *Text_element_data) GetName() (res string)

for satisfaction of GongStruct interface

func (*Text_element_data) Stage 

func (text_element_data *Text_element_data) Stage(stage *StageStruct) *Text_element_data

Stage puts text_element_data to the model stage

func (*Text_element_data) Unstage 

func (text_element_data *Text_element_data) Unstage(stage *StageStruct) *Text_element_data

Unstage removes text_element_data off the model stage

func (*Text_element_data) UnstageVoid 

func (text_element_data *Text_element_data) UnstageVoid(stage *StageStruct)

UnstageVoid removes text_element_data off the model stage

type Text_element_data_WOP 

type Text_element_data_WOP struct {
	// insertion point
	Name        string
	Value       string
	EmptyString string
}

type Tie 

type Tie struct {
	Name string
	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Time_only *Time_only `xml:"time-only,attr,omitempty" json:"time-only,omitempty"`
}

func CopyBranchTie 

func CopyBranchTie(mapOrigCopy map[any]any, tieFrom *Tie) (tieTo *Tie)

func (*Tie) Checkout 

func (tie *Tie) Checkout(stage *StageStruct) *Tie

Checkout tie to the back repo (if it is already staged)

func (*Tie) Commit 

func (tie *Tie) Commit(stage *StageStruct) *Tie

commit tie to the back repo (if it is already staged)

func (*Tie) CommitVoid 

func (tie *Tie) CommitVoid(stage *StageStruct)

func (*Tie) CopyBasicFields 

func (from *Tie) CopyBasicFields(to *Tie)

func (*Tie) GetName 

func (tie *Tie) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tie) Stage 

func (tie *Tie) Stage(stage *StageStruct) *Tie

Stage puts tie to the model stage

func (*Tie) Unstage 

func (tie *Tie) Unstage(stage *StageStruct) *Tie

Unstage removes tie off the model stage

func (*Tie) UnstageVoid 

func (tie *Tie) UnstageVoid(stage *StageStruct)

UnstageVoid removes tie off the model stage

type Tie_WOP 

type Tie_WOP struct {
	// insertion point
	Name string
}

type Tied 

type Tied struct {
	Name string
	Type *Tied_type `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchTied 

func CopyBranchTied(mapOrigCopy map[any]any, tiedFrom *Tied) (tiedTo *Tied)

func (*Tied) Checkout 

func (tied *Tied) Checkout(stage *StageStruct) *Tied

Checkout tied to the back repo (if it is already staged)

func (*Tied) Commit 

func (tied *Tied) Commit(stage *StageStruct) *Tied

commit tied to the back repo (if it is already staged)

func (*Tied) CommitVoid 

func (tied *Tied) CommitVoid(stage *StageStruct)

func (*Tied) CopyBasicFields 

func (from *Tied) CopyBasicFields(to *Tied)

func (*Tied) GetName 

func (tied *Tied) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tied) Stage 

func (tied *Tied) Stage(stage *StageStruct) *Tied

Stage puts tied to the model stage

func (*Tied) Unstage 

func (tied *Tied) Unstage(stage *StageStruct) *Tied

Unstage removes tied off the model stage

func (*Tied) UnstageVoid 

func (tied *Tied) UnstageVoid(stage *StageStruct)

UnstageVoid removes tied off the model stage

type Tied_WOP 

type Tied_WOP struct {
	// insertion point
	Name string
}

type Tied_type 

type Tied_type string
const (
	Tied_typeStart Tied_type = "start"

	Tied_typeStop Tied_type = "stop"

	Tied_typeContinue_ Tied_type = "continue"

	Tied_typeLet_ring Tied_type = "let-ring"
)

func (Tied_type) CodeValues 

func (tied_type Tied_type) CodeValues() (res []string)

func (Tied_type) Codes 

func (tied_type Tied_type) Codes() (res []string)

func (*Tied_type) FromCodeString 

func (tied_type *Tied_type) FromCodeString(input string) (err error)

func (*Tied_type) FromString 

func (tied_type *Tied_type) FromString(input string) (err error)

func (*Tied_type) ToCodeString 

func (tied_type *Tied_type) ToCodeString() (res string)

func (Tied_type) ToString 

func (tied_type Tied_type) ToString() (res string)

Utility function for Tied_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Time 

type Time struct {
	Name string

	// A senza-misura element explicitly indicates that no time
	// signature is present. The optional element content indicates the symbol to
	// be used, if any, such as an X. The time element's symbol attribute is not
	// used when a senza-misura element is present.
	Senza_misura string `xml:"senza-misura,omitempty" json:"senza-misura,omitempty"`

	Number *Staff_number `xml:"number,attr,omitempty" json:"number,omitempty"`

	Symbol *Time_symbol `xml:"symbol,attr,omitempty" json:"symbol,omitempty"`

	Separator *Time_separator `xml:"separator,attr,omitempty" json:"separator,omitempty"`
}

func CopyBranchTime 

func CopyBranchTime(mapOrigCopy map[any]any, timeFrom *Time) (timeTo *Time)

func (*Time) Checkout 

func (time *Time) Checkout(stage *StageStruct) *Time

Checkout time to the back repo (if it is already staged)

func (*Time) Commit 

func (time *Time) Commit(stage *StageStruct) *Time

commit time to the back repo (if it is already staged)

func (*Time) CommitVoid 

func (time *Time) CommitVoid(stage *StageStruct)

func (*Time) CopyBasicFields 

func (from *Time) CopyBasicFields(to *Time)

func (*Time) GetName 

func (time *Time) GetName() (res string)

for satisfaction of GongStruct interface

func (*Time) Stage 

func (time *Time) Stage(stage *StageStruct) *Time

Stage puts time to the model stage

func (*Time) Unstage 

func (time *Time) Unstage(stage *StageStruct) *Time

Unstage removes time off the model stage

func (*Time) UnstageVoid 

func (time *Time) UnstageVoid(stage *StageStruct)

UnstageVoid removes time off the model stage

type Time_WOP 

type Time_WOP struct {
	// insertion point
	Name         string
	Senza_misura string
}

type Time_modification 

type Time_modification struct {
	Name string

	// The actual-notes element describes how many notes are played
	// in the time usually occupied by the number in the normal-notes element.
	Actual_notes uint32 `xml:"actual-notes,omitempty" json:"actual-notes,omitempty"`

	// The normal-notes element describes how many notes are usually
	// played in the time occupied by the number in the actual-notes element.
	Normal_notes uint32 `xml:"normal-notes,omitempty" json:"normal-notes,omitempty"`
}

func CopyBranchTime_modification 

func CopyBranchTime_modification(mapOrigCopy map[any]any, time_modificationFrom *Time_modification) (time_modificationTo *Time_modification)

func (*Time_modification) Checkout 

func (time_modification *Time_modification) Checkout(stage *StageStruct) *Time_modification

Checkout time_modification to the back repo (if it is already staged)

func (*Time_modification) Commit 

func (time_modification *Time_modification) Commit(stage *StageStruct) *Time_modification

commit time_modification to the back repo (if it is already staged)

func (*Time_modification) CommitVoid 

func (time_modification *Time_modification) CommitVoid(stage *StageStruct)

func (*Time_modification) CopyBasicFields 

func (from *Time_modification) CopyBasicFields(to *Time_modification)

func (*Time_modification) GetName 

func (time_modification *Time_modification) GetName() (res string)

for satisfaction of GongStruct interface

func (*Time_modification) Stage 

func (time_modification *Time_modification) Stage(stage *StageStruct) *Time_modification

Stage puts time_modification to the model stage

func (*Time_modification) Unstage 

func (time_modification *Time_modification) Unstage(stage *StageStruct) *Time_modification

Unstage removes time_modification off the model stage

func (*Time_modification) UnstageVoid 

func (time_modification *Time_modification) UnstageVoid(stage *StageStruct)

UnstageVoid removes time_modification off the model stage

type Time_modification_WOP 

type Time_modification_WOP struct {
	// insertion point
	Name string
}

type Time_only 

type Time_only string

func (Time_only) CodeValues 

func (time_only Time_only) CodeValues() (res []string)

func (Time_only) Codes 

func (time_only Time_only) Codes() (res []string)

func (*Time_only) FromCodeString 

func (time_only *Time_only) FromCodeString(input string) (err error)

func (*Time_only) FromString 

func (time_only *Time_only) FromString(input string) (err error)

func (*Time_only) ToCodeString 

func (time_only *Time_only) ToCodeString() (res string)

func (Time_only) ToString 

func (time_only Time_only) ToString() (res string)

Utility function for Time_only if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Time_relation 

type Time_relation string
const (
	Time_relationParentheses Time_relation = "parentheses"

	Time_relationBracket Time_relation = "bracket"

	Time_relationEquals Time_relation = "equals"

	Time_relationSlash Time_relation = "slash"

	Time_relationSpace Time_relation = "space"

	Time_relationHyphen Time_relation = "hyphen"
)

func (Time_relation) CodeValues 

func (time_relation Time_relation) CodeValues() (res []string)

func (Time_relation) Codes 

func (time_relation Time_relation) Codes() (res []string)

func (*Time_relation) FromCodeString 

func (time_relation *Time_relation) FromCodeString(input string) (err error)

func (*Time_relation) FromString 

func (time_relation *Time_relation) FromString(input string) (err error)

func (*Time_relation) ToCodeString 

func (time_relation *Time_relation) ToCodeString() (res string)

func (Time_relation) ToString 

func (time_relation Time_relation) ToString() (res string)

Utility function for Time_relation if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Time_separator 

type Time_separator string
const (
	Time_separatorNone Time_separator = "none"

	Time_separatorHorizontal Time_separator = "horizontal"

	Time_separatorDiagonal Time_separator = "diagonal"

	Time_separatorVertical Time_separator = "vertical"

	Time_separatorAdjacent Time_separator = "adjacent"
)

func (Time_separator) CodeValues 

func (time_separator Time_separator) CodeValues() (res []string)

func (Time_separator) Codes 

func (time_separator Time_separator) Codes() (res []string)

func (*Time_separator) FromCodeString 

func (time_separator *Time_separator) FromCodeString(input string) (err error)

func (*Time_separator) FromString 

func (time_separator *Time_separator) FromString(input string) (err error)

func (*Time_separator) ToCodeString 

func (time_separator *Time_separator) ToCodeString() (res string)

func (Time_separator) ToString 

func (time_separator Time_separator) ToString() (res string)

Utility function for Time_separator if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Time_symbol 

type Time_symbol string
const (
	Time_symbolCommon Time_symbol = "common"

	Time_symbolCut Time_symbol = "cut"

	Time_symbolSingle_number Time_symbol = "single-number"

	Time_symbolNote Time_symbol = "note"

	Time_symbolDotted_note Time_symbol = "dotted-note"

	Time_symbolNormal Time_symbol = "normal"
)

func (Time_symbol) CodeValues 

func (time_symbol Time_symbol) CodeValues() (res []string)

func (Time_symbol) Codes 

func (time_symbol Time_symbol) Codes() (res []string)

func (*Time_symbol) FromCodeString 

func (time_symbol *Time_symbol) FromCodeString(input string) (err error)

func (*Time_symbol) FromString 

func (time_symbol *Time_symbol) FromString(input string) (err error)

func (*Time_symbol) ToCodeString 

func (time_symbol *Time_symbol) ToCodeString() (res string)

func (Time_symbol) ToString 

func (time_symbol Time_symbol) ToString() (res string)

Utility function for Time_symbol if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Timpani 

type Timpani struct {
	Name  string
	Smufl *Smufl_pictogram_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchTimpani 

func CopyBranchTimpani(mapOrigCopy map[any]any, timpaniFrom *Timpani) (timpaniTo *Timpani)

func (*Timpani) Checkout 

func (timpani *Timpani) Checkout(stage *StageStruct) *Timpani

Checkout timpani to the back repo (if it is already staged)

func (*Timpani) Commit 

func (timpani *Timpani) Commit(stage *StageStruct) *Timpani

commit timpani to the back repo (if it is already staged)

func (*Timpani) CommitVoid 

func (timpani *Timpani) CommitVoid(stage *StageStruct)

func (*Timpani) CopyBasicFields 

func (from *Timpani) CopyBasicFields(to *Timpani)

func (*Timpani) GetName 

func (timpani *Timpani) GetName() (res string)

for satisfaction of GongStruct interface

func (*Timpani) Stage 

func (timpani *Timpani) Stage(stage *StageStruct) *Timpani

Stage puts timpani to the model stage

func (*Timpani) Unstage 

func (timpani *Timpani) Unstage(stage *StageStruct) *Timpani

Unstage removes timpani off the model stage

func (*Timpani) UnstageVoid 

func (timpani *Timpani) UnstageVoid(stage *StageStruct)

UnstageVoid removes timpani off the model stage

type Timpani_WOP 

type Timpani_WOP struct {
	// insertion point
	Name string
}

type Tip_direction 

type Tip_direction string
const (
	Tip_directionUp Tip_direction = "up"

	Tip_directionDown Tip_direction = "down"

	Tip_directionLeft Tip_direction = "left"

	Tip_directionRight Tip_direction = "right"

	Tip_directionNorthwest Tip_direction = "northwest"

	Tip_directionNortheast Tip_direction = "northeast"

	Tip_directionSoutheast Tip_direction = "southeast"

	Tip_directionSouthwest Tip_direction = "southwest"
)

func (Tip_direction) CodeValues 

func (tip_direction Tip_direction) CodeValues() (res []string)

func (Tip_direction) Codes 

func (tip_direction Tip_direction) Codes() (res []string)

func (*Tip_direction) FromCodeString 

func (tip_direction *Tip_direction) FromCodeString(input string) (err error)

func (*Tip_direction) FromString 

func (tip_direction *Tip_direction) FromString(input string) (err error)

func (*Tip_direction) ToCodeString 

func (tip_direction *Tip_direction) ToCodeString() (res string)

func (Tip_direction) ToString 

func (tip_direction Tip_direction) ToString() (res string)

Utility function for Tip_direction if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Top_bottom 

type Top_bottom string
const (
	Top_bottomTop Top_bottom = "top"

	Top_bottomBottom Top_bottom = "bottom"
)

func (Top_bottom) CodeValues 

func (top_bottom Top_bottom) CodeValues() (res []string)

func (Top_bottom) Codes 

func (top_bottom Top_bottom) Codes() (res []string)

func (*Top_bottom) FromCodeString 

func (top_bottom *Top_bottom) FromCodeString(input string) (err error)

func (*Top_bottom) FromString 

func (top_bottom *Top_bottom) FromString(input string) (err error)

func (*Top_bottom) ToCodeString 

func (top_bottom *Top_bottom) ToCodeString() (res string)

func (Top_bottom) ToString 

func (top_bottom Top_bottom) ToString() (res string)

Utility function for Top_bottom if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Transpose 

type Transpose struct {
	Name   string
	Number *Staff_number `xml:"number,attr,omitempty" json:"number,omitempty"`
}

func CopyBranchTranspose 

func CopyBranchTranspose(mapOrigCopy map[any]any, transposeFrom *Transpose) (transposeTo *Transpose)

func (*Transpose) Checkout 

func (transpose *Transpose) Checkout(stage *StageStruct) *Transpose

Checkout transpose to the back repo (if it is already staged)

func (*Transpose) Commit 

func (transpose *Transpose) Commit(stage *StageStruct) *Transpose

commit transpose to the back repo (if it is already staged)

func (*Transpose) CommitVoid 

func (transpose *Transpose) CommitVoid(stage *StageStruct)

func (*Transpose) CopyBasicFields 

func (from *Transpose) CopyBasicFields(to *Transpose)

func (*Transpose) GetName 

func (transpose *Transpose) GetName() (res string)

for satisfaction of GongStruct interface

func (*Transpose) Stage 

func (transpose *Transpose) Stage(stage *StageStruct) *Transpose

Stage puts transpose to the model stage

func (*Transpose) Unstage 

func (transpose *Transpose) Unstage(stage *StageStruct) *Transpose

Unstage removes transpose off the model stage

func (*Transpose) UnstageVoid 

func (transpose *Transpose) UnstageVoid(stage *StageStruct)

UnstageVoid removes transpose off the model stage

type Transpose_WOP 

type Transpose_WOP struct {
	// insertion point
	Name string
}

type Tremolo 

type Tremolo struct {
	Name  string
	Value *Tremolo_marks `xml:",chardata" json:"-,"`

	Type *Tremolo_type `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchTremolo 

func CopyBranchTremolo(mapOrigCopy map[any]any, tremoloFrom *Tremolo) (tremoloTo *Tremolo)

func (*Tremolo) Checkout 

func (tremolo *Tremolo) Checkout(stage *StageStruct) *Tremolo

Checkout tremolo to the back repo (if it is already staged)

func (*Tremolo) Commit 

func (tremolo *Tremolo) Commit(stage *StageStruct) *Tremolo

commit tremolo to the back repo (if it is already staged)

func (*Tremolo) CommitVoid 

func (tremolo *Tremolo) CommitVoid(stage *StageStruct)

func (*Tremolo) CopyBasicFields 

func (from *Tremolo) CopyBasicFields(to *Tremolo)

func (*Tremolo) GetName 

func (tremolo *Tremolo) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tremolo) Stage 

func (tremolo *Tremolo) Stage(stage *StageStruct) *Tremolo

Stage puts tremolo to the model stage

func (*Tremolo) Unstage 

func (tremolo *Tremolo) Unstage(stage *StageStruct) *Tremolo

Unstage removes tremolo off the model stage

func (*Tremolo) UnstageVoid 

func (tremolo *Tremolo) UnstageVoid(stage *StageStruct)

UnstageVoid removes tremolo off the model stage

type Tremolo_WOP 

type Tremolo_WOP struct {
	// insertion point
	Name string
}

type Tremolo_marks 

type Tremolo_marks int32

type Tremolo_type 

type Tremolo_type string
const (
	Tremolo_typeStart Tremolo_type = "start"

	Tremolo_typeStop Tremolo_type = "stop"

	Tremolo_typeSingle Tremolo_type = "single"

	Tremolo_typeUnmeasured Tremolo_type = "unmeasured"
)

func (Tremolo_type) CodeValues 

func (tremolo_type Tremolo_type) CodeValues() (res []string)

func (Tremolo_type) Codes 

func (tremolo_type Tremolo_type) Codes() (res []string)

func (*Tremolo_type) FromCodeString 

func (tremolo_type *Tremolo_type) FromCodeString(input string) (err error)

func (*Tremolo_type) FromString 

func (tremolo_type *Tremolo_type) FromString(input string) (err error)

func (*Tremolo_type) ToCodeString 

func (tremolo_type *Tremolo_type) ToCodeString() (res string)

func (Tremolo_type) ToString 

func (tremolo_type Tremolo_type) ToString() (res string)

Utility function for Tremolo_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Trill_beats 

type Trill_beats float64

type Trill_step 

type Trill_step string
const (
	Trill_stepWhole Trill_step = "whole"

	Trill_stepHalf Trill_step = "half"

	Trill_stepUnison Trill_step = "unison"
)

func (Trill_step) CodeValues 

func (trill_step Trill_step) CodeValues() (res []string)

func (Trill_step) Codes 

func (trill_step Trill_step) Codes() (res []string)

func (*Trill_step) FromCodeString 

func (trill_step *Trill_step) FromCodeString(input string) (err error)

func (*Trill_step) FromString 

func (trill_step *Trill_step) FromString(input string) (err error)

func (*Trill_step) ToCodeString 

func (trill_step *Trill_step) ToCodeString() (res string)

func (Trill_step) ToString 

func (trill_step Trill_step) ToString() (res string)

Utility function for Trill_step if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Tuplet 

type Tuplet struct {
	Name string

	// The tuplet-actual element provide optional full control over
	// how the actual part of the tuplet is displayed, including number and note
	// type (with dots). If any of these elements are absent, their values are
	// based on the time-modification element.
	Tuplet_actual *Tuplet_portion `xml:"tuplet-actual,omitempty" json:"tuplet-actual,omitempty"`

	// The tuplet-normal element provide optional full control over
	// how the normal part of the tuplet is displayed, including number and note
	// type (with dots). If any of these elements are absent, their values are
	// based on the time-modification element.
	Tuplet_normal *Tuplet_portion `xml:"tuplet-normal,omitempty" json:"tuplet-normal,omitempty"`

	Type *Start_stop `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`

	Bracket *Yes_no `xml:"bracket,attr,omitempty" json:"bracket,omitempty"`

	Show_number *Show_tuplet `xml:"show-number,attr,omitempty" json:"show-number,omitempty"`

	Show_type *Show_tuplet `xml:"show-type,attr,omitempty" json:"show-type,omitempty"`
}

func CopyBranchTuplet 

func CopyBranchTuplet(mapOrigCopy map[any]any, tupletFrom *Tuplet) (tupletTo *Tuplet)

func (*Tuplet) Checkout 

func (tuplet *Tuplet) Checkout(stage *StageStruct) *Tuplet

Checkout tuplet to the back repo (if it is already staged)

func (*Tuplet) Commit 

func (tuplet *Tuplet) Commit(stage *StageStruct) *Tuplet

commit tuplet to the back repo (if it is already staged)

func (*Tuplet) CommitVoid 

func (tuplet *Tuplet) CommitVoid(stage *StageStruct)

func (*Tuplet) CopyBasicFields 

func (from *Tuplet) CopyBasicFields(to *Tuplet)

func (*Tuplet) GetName 

func (tuplet *Tuplet) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tuplet) Stage 

func (tuplet *Tuplet) Stage(stage *StageStruct) *Tuplet

Stage puts tuplet to the model stage

func (*Tuplet) Unstage 

func (tuplet *Tuplet) Unstage(stage *StageStruct) *Tuplet

Unstage removes tuplet off the model stage

func (*Tuplet) UnstageVoid 

func (tuplet *Tuplet) UnstageVoid(stage *StageStruct)

UnstageVoid removes tuplet off the model stage

type Tuplet_WOP 

type Tuplet_WOP struct {
	// insertion point
	Name string
}

type Tuplet_dot 

type Tuplet_dot struct {
	Name string
}

func CopyBranchTuplet_dot 

func CopyBranchTuplet_dot(mapOrigCopy map[any]any, tuplet_dotFrom *Tuplet_dot) (tuplet_dotTo *Tuplet_dot)

func (*Tuplet_dot) Checkout 

func (tuplet_dot *Tuplet_dot) Checkout(stage *StageStruct) *Tuplet_dot

Checkout tuplet_dot to the back repo (if it is already staged)

func (*Tuplet_dot) Commit 

func (tuplet_dot *Tuplet_dot) Commit(stage *StageStruct) *Tuplet_dot

commit tuplet_dot to the back repo (if it is already staged)

func (*Tuplet_dot) CommitVoid 

func (tuplet_dot *Tuplet_dot) CommitVoid(stage *StageStruct)

func (*Tuplet_dot) CopyBasicFields 

func (from *Tuplet_dot) CopyBasicFields(to *Tuplet_dot)

func (*Tuplet_dot) GetName 

func (tuplet_dot *Tuplet_dot) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tuplet_dot) Stage 

func (tuplet_dot *Tuplet_dot) Stage(stage *StageStruct) *Tuplet_dot

Stage puts tuplet_dot to the model stage

func (*Tuplet_dot) Unstage 

func (tuplet_dot *Tuplet_dot) Unstage(stage *StageStruct) *Tuplet_dot

Unstage removes tuplet_dot off the model stage

func (*Tuplet_dot) UnstageVoid 

func (tuplet_dot *Tuplet_dot) UnstageVoid(stage *StageStruct)

UnstageVoid removes tuplet_dot off the model stage

type Tuplet_dot_WOP 

type Tuplet_dot_WOP struct {
	// insertion point
	Name string
}

type Tuplet_number 

type Tuplet_number struct {
	Name  string
	Value uint32 `xml:",chardata" json:"-,"`
}

func CopyBranchTuplet_number 

func CopyBranchTuplet_number(mapOrigCopy map[any]any, tuplet_numberFrom *Tuplet_number) (tuplet_numberTo *Tuplet_number)

func (*Tuplet_number) Checkout 

func (tuplet_number *Tuplet_number) Checkout(stage *StageStruct) *Tuplet_number

Checkout tuplet_number to the back repo (if it is already staged)

func (*Tuplet_number) Commit 

func (tuplet_number *Tuplet_number) Commit(stage *StageStruct) *Tuplet_number

commit tuplet_number to the back repo (if it is already staged)

func (*Tuplet_number) CommitVoid 

func (tuplet_number *Tuplet_number) CommitVoid(stage *StageStruct)

func (*Tuplet_number) CopyBasicFields 

func (from *Tuplet_number) CopyBasicFields(to *Tuplet_number)

func (*Tuplet_number) GetName 

func (tuplet_number *Tuplet_number) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tuplet_number) Stage 

func (tuplet_number *Tuplet_number) Stage(stage *StageStruct) *Tuplet_number

Stage puts tuplet_number to the model stage

func (*Tuplet_number) Unstage 

func (tuplet_number *Tuplet_number) Unstage(stage *StageStruct) *Tuplet_number

Unstage removes tuplet_number off the model stage

func (*Tuplet_number) UnstageVoid 

func (tuplet_number *Tuplet_number) UnstageVoid(stage *StageStruct)

UnstageVoid removes tuplet_number off the model stage

type Tuplet_number_WOP 

type Tuplet_number_WOP struct {
	// insertion point
	Name string
}

type Tuplet_portion 

type Tuplet_portion struct {
	Name          string
	Tuplet_number *Tuplet_number `xml:"tuplet-number,omitempty" json:"tuplet-number,omitempty"`

	Tuplet_type *Tuplet_type `xml:"tuplet-type,omitempty" json:"tuplet-type,omitempty"`

	Tuplet_dot []*Tuplet_dot `xml:"tuplet-dot,omitempty" json:"tuplet-dot,omitempty"`
}

func CopyBranchTuplet_portion 

func CopyBranchTuplet_portion(mapOrigCopy map[any]any, tuplet_portionFrom *Tuplet_portion) (tuplet_portionTo *Tuplet_portion)

func (*Tuplet_portion) Checkout 

func (tuplet_portion *Tuplet_portion) Checkout(stage *StageStruct) *Tuplet_portion

Checkout tuplet_portion to the back repo (if it is already staged)

func (*Tuplet_portion) Commit 

func (tuplet_portion *Tuplet_portion) Commit(stage *StageStruct) *Tuplet_portion

commit tuplet_portion to the back repo (if it is already staged)

func (*Tuplet_portion) CommitVoid 

func (tuplet_portion *Tuplet_portion) CommitVoid(stage *StageStruct)

func (*Tuplet_portion) CopyBasicFields 

func (from *Tuplet_portion) CopyBasicFields(to *Tuplet_portion)

func (*Tuplet_portion) GetName 

func (tuplet_portion *Tuplet_portion) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tuplet_portion) Stage 

func (tuplet_portion *Tuplet_portion) Stage(stage *StageStruct) *Tuplet_portion

Stage puts tuplet_portion to the model stage

func (*Tuplet_portion) Unstage 

func (tuplet_portion *Tuplet_portion) Unstage(stage *StageStruct) *Tuplet_portion

Unstage removes tuplet_portion off the model stage

func (*Tuplet_portion) UnstageVoid 

func (tuplet_portion *Tuplet_portion) UnstageVoid(stage *StageStruct)

UnstageVoid removes tuplet_portion off the model stage

type Tuplet_portion_WOP 

type Tuplet_portion_WOP struct {
	// insertion point
	Name string
}

type Tuplet_type 

type Tuplet_type struct {
	Name  string
	Value *Note_type_value `xml:",chardata" json:"-,"`
}

func CopyBranchTuplet_type 

func CopyBranchTuplet_type(mapOrigCopy map[any]any, tuplet_typeFrom *Tuplet_type) (tuplet_typeTo *Tuplet_type)

func (*Tuplet_type) Checkout 

func (tuplet_type *Tuplet_type) Checkout(stage *StageStruct) *Tuplet_type

Checkout tuplet_type to the back repo (if it is already staged)

func (*Tuplet_type) Commit 

func (tuplet_type *Tuplet_type) Commit(stage *StageStruct) *Tuplet_type

commit tuplet_type to the back repo (if it is already staged)

func (*Tuplet_type) CommitVoid 

func (tuplet_type *Tuplet_type) CommitVoid(stage *StageStruct)

func (*Tuplet_type) CopyBasicFields 

func (from *Tuplet_type) CopyBasicFields(to *Tuplet_type)

func (*Tuplet_type) GetName 

func (tuplet_type *Tuplet_type) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tuplet_type) Stage 

func (tuplet_type *Tuplet_type) Stage(stage *StageStruct) *Tuplet_type

Stage puts tuplet_type to the model stage

func (*Tuplet_type) Unstage 

func (tuplet_type *Tuplet_type) Unstage(stage *StageStruct) *Tuplet_type

Unstage removes tuplet_type off the model stage

func (*Tuplet_type) UnstageVoid 

func (tuplet_type *Tuplet_type) UnstageVoid(stage *StageStruct)

UnstageVoid removes tuplet_type off the model stage

type Tuplet_type_WOP 

type Tuplet_type_WOP struct {
	// insertion point
	Name string
}

type Two_note_turn 

type Two_note_turn string
const (
	Two_note_turnWhole Two_note_turn = "whole"

	Two_note_turnHalf Two_note_turn = "half"

	Two_note_turnNone Two_note_turn = "none"
)

func (Two_note_turn) CodeValues 

func (two_note_turn Two_note_turn) CodeValues() (res []string)

func (Two_note_turn) Codes 

func (two_note_turn Two_note_turn) Codes() (res []string)

func (*Two_note_turn) FromCodeString 

func (two_note_turn *Two_note_turn) FromCodeString(input string) (err error)

func (*Two_note_turn) FromString 

func (two_note_turn *Two_note_turn) FromString(input string) (err error)

func (*Two_note_turn) ToCodeString 

func (two_note_turn *Two_note_turn) ToCodeString() (res string)

func (Two_note_turn) ToString 

func (two_note_turn Two_note_turn) ToString() (res string)

Utility function for Two_note_turn if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Typed_text 

type Typed_text struct {
	Name  string
	Value string `xml:",chardata" json:"-,"`

	Type string `xml:"type,attr,omitempty" json:"type,omitempty"`
}

func CopyBranchTyped_text 

func CopyBranchTyped_text(mapOrigCopy map[any]any, typed_textFrom *Typed_text) (typed_textTo *Typed_text)

func (*Typed_text) Checkout 

func (typed_text *Typed_text) Checkout(stage *StageStruct) *Typed_text

Checkout typed_text to the back repo (if it is already staged)

func (*Typed_text) Commit 

func (typed_text *Typed_text) Commit(stage *StageStruct) *Typed_text

commit typed_text to the back repo (if it is already staged)

func (*Typed_text) CommitVoid 

func (typed_text *Typed_text) CommitVoid(stage *StageStruct)

func (*Typed_text) CopyBasicFields 

func (from *Typed_text) CopyBasicFields(to *Typed_text)

func (*Typed_text) GetName 

func (typed_text *Typed_text) GetName() (res string)

for satisfaction of GongStruct interface

func (*Typed_text) Stage 

func (typed_text *Typed_text) Stage(stage *StageStruct) *Typed_text

Stage puts typed_text to the model stage

func (*Typed_text) Unstage 

func (typed_text *Typed_text) Unstage(stage *StageStruct) *Typed_text

Unstage removes typed_text off the model stage

func (*Typed_text) UnstageVoid 

func (typed_text *Typed_text) UnstageVoid(stage *StageStruct)

UnstageVoid removes typed_text off the model stage

type Typed_text_WOP 

type Typed_text_WOP struct {
	// insertion point
	Name  string
	Value string
	Type  string
}

type Unpitched 

type Unpitched struct {
	Name string
}

func CopyBranchUnpitched 

func CopyBranchUnpitched(mapOrigCopy map[any]any, unpitchedFrom *Unpitched) (unpitchedTo *Unpitched)

func (*Unpitched) Checkout 

func (unpitched *Unpitched) Checkout(stage *StageStruct) *Unpitched

Checkout unpitched to the back repo (if it is already staged)

func (*Unpitched) Commit 

func (unpitched *Unpitched) Commit(stage *StageStruct) *Unpitched

commit unpitched to the back repo (if it is already staged)

func (*Unpitched) CommitVoid 

func (unpitched *Unpitched) CommitVoid(stage *StageStruct)

func (*Unpitched) CopyBasicFields 

func (from *Unpitched) CopyBasicFields(to *Unpitched)

func (*Unpitched) GetName 

func (unpitched *Unpitched) GetName() (res string)

for satisfaction of GongStruct interface

func (*Unpitched) Stage 

func (unpitched *Unpitched) Stage(stage *StageStruct) *Unpitched

Stage puts unpitched to the model stage

func (*Unpitched) Unstage 

func (unpitched *Unpitched) Unstage(stage *StageStruct) *Unpitched

Unstage removes unpitched off the model stage

func (*Unpitched) UnstageVoid 

func (unpitched *Unpitched) UnstageVoid(stage *StageStruct)

UnstageVoid removes unpitched off the model stage

type Unpitched_WOP 

type Unpitched_WOP struct {
	// insertion point
	Name string
}

type Up_down 

type Up_down string
const (
	Up_downUp Up_down = "up"

	Up_downDown Up_down = "down"
)

func (Up_down) CodeValues 

func (up_down Up_down) CodeValues() (res []string)

func (Up_down) Codes 

func (up_down Up_down) Codes() (res []string)

func (*Up_down) FromCodeString 

func (up_down *Up_down) FromCodeString(input string) (err error)

func (*Up_down) FromString 

func (up_down *Up_down) FromString(input string) (err error)

func (*Up_down) ToCodeString 

func (up_down *Up_down) ToCodeString() (res string)

func (Up_down) ToString 

func (up_down Up_down) ToString() (res string)

Utility function for Up_down if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Up_down_stop_continue 

type Up_down_stop_continue string
const (
	Up_down_stop_continueUp Up_down_stop_continue = "up"

	Up_down_stop_continueDown Up_down_stop_continue = "down"

	Up_down_stop_continueStop Up_down_stop_continue = "stop"

	Up_down_stop_continueContinue_ Up_down_stop_continue = "continue"
)

func (Up_down_stop_continue) CodeValues 

func (up_down_stop_continue Up_down_stop_continue) CodeValues() (res []string)

func (Up_down_stop_continue) Codes 

func (up_down_stop_continue Up_down_stop_continue) Codes() (res []string)

func (*Up_down_stop_continue) FromCodeString 

func (up_down_stop_continue *Up_down_stop_continue) FromCodeString(input string) (err error)

func (*Up_down_stop_continue) FromString 

func (up_down_stop_continue *Up_down_stop_continue) FromString(input string) (err error)

func (*Up_down_stop_continue) ToCodeString 

func (up_down_stop_continue *Up_down_stop_continue) ToCodeString() (res string)

func (Up_down_stop_continue) ToString 

func (up_down_stop_continue Up_down_stop_continue) ToString() (res string)

Utility function for Up_down_stop_continue if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Upright_inverted 

type Upright_inverted string
const (
	Upright_invertedUpright Upright_inverted = "upright"

	Upright_invertedInverted Upright_inverted = "inverted"
)

func (Upright_inverted) CodeValues 

func (upright_inverted Upright_inverted) CodeValues() (res []string)

func (Upright_inverted) Codes 

func (upright_inverted Upright_inverted) Codes() (res []string)

func (*Upright_inverted) FromCodeString 

func (upright_inverted *Upright_inverted) FromCodeString(input string) (err error)

func (*Upright_inverted) FromString 

func (upright_inverted *Upright_inverted) FromString(input string) (err error)

func (*Upright_inverted) ToCodeString 

func (upright_inverted *Upright_inverted) ToCodeString() (res string)

func (Upright_inverted) ToString 

func (upright_inverted Upright_inverted) ToString() (res string)

Utility function for Upright_inverted if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Valign 

type Valign string
const (
	ValignTop Valign = "top"

	ValignMiddle Valign = "middle"

	ValignBottom Valign = "bottom"

	ValignBaseline Valign = "baseline"
)

func (Valign) CodeValues 

func (valign Valign) CodeValues() (res []string)

func (Valign) Codes 

func (valign Valign) Codes() (res []string)

func (*Valign) FromCodeString 

func (valign *Valign) FromCodeString(input string) (err error)

func (*Valign) FromString 

func (valign *Valign) FromString(input string) (err error)

func (*Valign) ToCodeString 

func (valign *Valign) ToCodeString() (res string)

func (Valign) ToString 

func (valign Valign) ToString() (res string)

Utility function for Valign if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Valign_image 

type Valign_image string
const (
	Valign_imageTop Valign_image = "top"

	Valign_imageMiddle Valign_image = "middle"

	Valign_imageBottom Valign_image = "bottom"
)

func (Valign_image) CodeValues 

func (valign_image Valign_image) CodeValues() (res []string)

func (Valign_image) Codes 

func (valign_image Valign_image) Codes() (res []string)

func (*Valign_image) FromCodeString 

func (valign_image *Valign_image) FromCodeString(input string) (err error)

func (*Valign_image) FromString 

func (valign_image *Valign_image) FromString(input string) (err error)

func (*Valign_image) ToCodeString 

func (valign_image *Valign_image) ToCodeString() (res string)

func (Valign_image) ToString 

func (valign_image Valign_image) ToString() (res string)

Utility function for Valign_image if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Virtual_instrument 

type Virtual_instrument struct {
	Name string

	// The virtual-library element indicates the virtual instrument
	// library name.
	Virtual_library string `xml:"virtual-library,omitempty" json:"virtual-library,omitempty"`

	// The virtual-name element indicates the library-specific name
	// for the virtual instrument.
	Virtual_name string `xml:"virtual-name,omitempty" json:"virtual-name,omitempty"`
}

func CopyBranchVirtual_instrument 

func CopyBranchVirtual_instrument(mapOrigCopy map[any]any, virtual_instrumentFrom *Virtual_instrument) (virtual_instrumentTo *Virtual_instrument)

func (*Virtual_instrument) Checkout 

func (virtual_instrument *Virtual_instrument) Checkout(stage *StageStruct) *Virtual_instrument

Checkout virtual_instrument to the back repo (if it is already staged)

func (*Virtual_instrument) Commit 

func (virtual_instrument *Virtual_instrument) Commit(stage *StageStruct) *Virtual_instrument

commit virtual_instrument to the back repo (if it is already staged)

func (*Virtual_instrument) CommitVoid 

func (virtual_instrument *Virtual_instrument) CommitVoid(stage *StageStruct)

func (*Virtual_instrument) CopyBasicFields 

func (from *Virtual_instrument) CopyBasicFields(to *Virtual_instrument)

func (*Virtual_instrument) GetName 

func (virtual_instrument *Virtual_instrument) GetName() (res string)

for satisfaction of GongStruct interface

func (*Virtual_instrument) Stage 

func (virtual_instrument *Virtual_instrument) Stage(stage *StageStruct) *Virtual_instrument

Stage puts virtual_instrument to the model stage

func (*Virtual_instrument) Unstage 

func (virtual_instrument *Virtual_instrument) Unstage(stage *StageStruct) *Virtual_instrument

Unstage removes virtual_instrument off the model stage

func (*Virtual_instrument) UnstageVoid 

func (virtual_instrument *Virtual_instrument) UnstageVoid(stage *StageStruct)

UnstageVoid removes virtual_instrument off the model stage

type Virtual_instrument_WOP 

type Virtual_instrument_WOP struct {
	// insertion point
	Name            string
	Virtual_library string
	Virtual_name    string
}

type Wait 

type Wait struct {
	Name   string
	Player *IDREF `xml:"player,attr,omitempty" json:"player,omitempty"`

	Time_only *Time_only `xml:"time-only,attr,omitempty" json:"time-only,omitempty"`
}

func CopyBranchWait 

func CopyBranchWait(mapOrigCopy map[any]any, waitFrom *Wait) (waitTo *Wait)

func (*Wait) Checkout 

func (wait *Wait) Checkout(stage *StageStruct) *Wait

Checkout wait to the back repo (if it is already staged)

func (*Wait) Commit 

func (wait *Wait) Commit(stage *StageStruct) *Wait

commit wait to the back repo (if it is already staged)

func (*Wait) CommitVoid 

func (wait *Wait) CommitVoid(stage *StageStruct)

func (*Wait) CopyBasicFields 

func (from *Wait) CopyBasicFields(to *Wait)

func (*Wait) GetName 

func (wait *Wait) GetName() (res string)

for satisfaction of GongStruct interface

func (*Wait) Stage 

func (wait *Wait) Stage(stage *StageStruct) *Wait

Stage puts wait to the model stage

func (*Wait) Unstage 

func (wait *Wait) Unstage(stage *StageStruct) *Wait

Unstage removes wait off the model stage

func (*Wait) UnstageVoid 

func (wait *Wait) UnstageVoid(stage *StageStruct)

UnstageVoid removes wait off the model stage

type Wait_WOP 

type Wait_WOP struct {
	// insertion point
	Name string
}

type Wavy_line 

type Wavy_line struct {
	Name string
	Type *Start_stop_continue `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`

	Smufl *Smufl_wavy_line_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchWavy_line 

func CopyBranchWavy_line(mapOrigCopy map[any]any, wavy_lineFrom *Wavy_line) (wavy_lineTo *Wavy_line)

func (*Wavy_line) Checkout 

func (wavy_line *Wavy_line) Checkout(stage *StageStruct) *Wavy_line

Checkout wavy_line to the back repo (if it is already staged)

func (*Wavy_line) Commit 

func (wavy_line *Wavy_line) Commit(stage *StageStruct) *Wavy_line

commit wavy_line to the back repo (if it is already staged)

func (*Wavy_line) CommitVoid 

func (wavy_line *Wavy_line) CommitVoid(stage *StageStruct)

func (*Wavy_line) CopyBasicFields 

func (from *Wavy_line) CopyBasicFields(to *Wavy_line)

func (*Wavy_line) GetName 

func (wavy_line *Wavy_line) GetName() (res string)

for satisfaction of GongStruct interface

func (*Wavy_line) Stage 

func (wavy_line *Wavy_line) Stage(stage *StageStruct) *Wavy_line

Stage puts wavy_line to the model stage

func (*Wavy_line) Unstage 

func (wavy_line *Wavy_line) Unstage(stage *StageStruct) *Wavy_line

Unstage removes wavy_line off the model stage

func (*Wavy_line) UnstageVoid 

func (wavy_line *Wavy_line) UnstageVoid(stage *StageStruct)

UnstageVoid removes wavy_line off the model stage

type Wavy_line_WOP 

type Wavy_line_WOP struct {
	// insertion point
	Name string
}

type Wedge 

type Wedge struct {
	Name string
	Type *Wedge_type `xml:"type,attr,omitempty" json:"type,omitempty"`

	Number *Number_level `xml:"number,attr,omitempty" json:"number,omitempty"`

	Spread *Tenths `xml:"spread,attr,omitempty" json:"spread,omitempty"`

	Niente *Yes_no `xml:"niente,attr,omitempty" json:"niente,omitempty"`
}

func CopyBranchWedge 

func CopyBranchWedge(mapOrigCopy map[any]any, wedgeFrom *Wedge) (wedgeTo *Wedge)

func (*Wedge) Checkout 

func (wedge *Wedge) Checkout(stage *StageStruct) *Wedge

Checkout wedge to the back repo (if it is already staged)

func (*Wedge) Commit 

func (wedge *Wedge) Commit(stage *StageStruct) *Wedge

commit wedge to the back repo (if it is already staged)

func (*Wedge) CommitVoid 

func (wedge *Wedge) CommitVoid(stage *StageStruct)

func (*Wedge) CopyBasicFields 

func (from *Wedge) CopyBasicFields(to *Wedge)

func (*Wedge) GetName 

func (wedge *Wedge) GetName() (res string)

for satisfaction of GongStruct interface

func (*Wedge) Stage 

func (wedge *Wedge) Stage(stage *StageStruct) *Wedge

Stage puts wedge to the model stage

func (*Wedge) Unstage 

func (wedge *Wedge) Unstage(stage *StageStruct) *Wedge

Unstage removes wedge off the model stage

func (*Wedge) UnstageVoid 

func (wedge *Wedge) UnstageVoid(stage *StageStruct)

UnstageVoid removes wedge off the model stage

type Wedge_WOP 

type Wedge_WOP struct {
	// insertion point
	Name string
}

type Wedge_type 

type Wedge_type string
const (
	Wedge_typeCrescendo Wedge_type = "crescendo"

	Wedge_typeDiminuendo Wedge_type = "diminuendo"

	Wedge_typeStop Wedge_type = "stop"

	Wedge_typeContinue_ Wedge_type = "continue"
)

func (Wedge_type) CodeValues 

func (wedge_type Wedge_type) CodeValues() (res []string)

func (Wedge_type) Codes 

func (wedge_type Wedge_type) Codes() (res []string)

func (*Wedge_type) FromCodeString 

func (wedge_type *Wedge_type) FromCodeString(input string) (err error)

func (*Wedge_type) FromString 

func (wedge_type *Wedge_type) FromString(input string) (err error)

func (*Wedge_type) ToCodeString 

func (wedge_type *Wedge_type) ToCodeString() (res string)

func (Wedge_type) ToString 

func (wedge_type Wedge_type) ToString() (res string)

Utility function for Wedge_type if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Winged 

type Winged string
const (
	WingedNone Winged = "none"

	WingedStraight Winged = "straight"

	WingedCurved Winged = "curved"

	WingedDouble_straight Winged = "double-straight"

	WingedDouble_curved Winged = "double-curved"
)

func (Winged) CodeValues 

func (winged Winged) CodeValues() (res []string)

func (Winged) Codes 

func (winged Winged) Codes() (res []string)

func (*Winged) FromCodeString 

func (winged *Winged) FromCodeString(input string) (err error)

func (*Winged) FromString 

func (winged *Winged) FromString(input string) (err error)

func (*Winged) ToCodeString 

func (winged *Winged) ToCodeString() (res string)

func (Winged) ToString 

func (winged Winged) ToString() (res string)

Utility function for Winged if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Wood 

type Wood struct {
	Name  string
	Value *Wood_value `xml:",chardata" json:"-,"`

	Smufl *Smufl_pictogram_glyph_name `xml:"smufl,attr,omitempty" json:"smufl,omitempty"`
}

func CopyBranchWood 

func CopyBranchWood(mapOrigCopy map[any]any, woodFrom *Wood) (woodTo *Wood)

func (*Wood) Checkout 

func (wood *Wood) Checkout(stage *StageStruct) *Wood

Checkout wood to the back repo (if it is already staged)

func (*Wood) Commit 

func (wood *Wood) Commit(stage *StageStruct) *Wood

commit wood to the back repo (if it is already staged)

func (*Wood) CommitVoid 

func (wood *Wood) CommitVoid(stage *StageStruct)

func (*Wood) CopyBasicFields 

func (from *Wood) CopyBasicFields(to *Wood)

func (*Wood) GetName 

func (wood *Wood) GetName() (res string)

for satisfaction of GongStruct interface

func (*Wood) Stage 

func (wood *Wood) Stage(stage *StageStruct) *Wood

Stage puts wood to the model stage

func (*Wood) Unstage 

func (wood *Wood) Unstage(stage *StageStruct) *Wood

Unstage removes wood off the model stage

func (*Wood) UnstageVoid 

func (wood *Wood) UnstageVoid(stage *StageStruct)

UnstageVoid removes wood off the model stage

type Wood_WOP 

type Wood_WOP struct {
	// insertion point
	Name string
}

type Wood_value 

type Wood_value string
const (
	Wood_valueBambooscraper Wood_value = "bamboo scraper"

	Wood_valueBoardclapper Wood_value = "board clapper"

	Wood_valueCabasa Wood_value = "cabasa"

	Wood_valueCastanets Wood_value = "castanets"

	Wood_valueCastanetswithhandle Wood_value = "castanets with handle"

	Wood_valueClaves Wood_value = "claves"

	Wood_valueFootballrattle Wood_value = "football rattle"

	Wood_valueGuiro Wood_value = "guiro"

	Wood_valueLogdrum Wood_value = "log drum"

	Wood_valueMaraca Wood_value = "maraca"

	Wood_valueMaracas Wood_value = "maracas"

	Wood_valueQuijada Wood_value = "quijada"

	Wood_valueRainstick Wood_value = "rainstick"

	Wood_valueRatchet Wood_value = "ratchet"

	Wood_valueReco_reco Wood_value = "reco-reco"

	Wood_valueSandpaperblocks Wood_value = "sandpaper blocks"

	Wood_valueSlitdrum Wood_value = "slit drum"

	Wood_valueTempleblock Wood_value = "temple block"

	Wood_valueVibraslap Wood_value = "vibraslap"

	Wood_valueWhip Wood_value = "whip"

	Wood_valueWoodblock Wood_value = "wood block"
)

func (Wood_value) CodeValues 

func (wood_value Wood_value) CodeValues() (res []string)

func (Wood_value) Codes 

func (wood_value Wood_value) Codes() (res []string)

func (*Wood_value) FromCodeString 

func (wood_value *Wood_value) FromCodeString(input string) (err error)

func (*Wood_value) FromString 

func (wood_value *Wood_value) FromString(input string) (err error)

func (*Wood_value) ToCodeString 

func (wood_value *Wood_value) ToCodeString() (res string)

func (Wood_value) ToString 

func (wood_value Wood_value) ToString() (res string)

Utility function for Wood_value if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Work 

type Work struct {
	Name string

	// The work-number element specifies the number of a work, such
	// as its opus number.
	Work_number string `xml:"work-number,omitempty" json:"work-number,omitempty"`

	// The work-title element specifies the title of a work, not
	// including its opus or other work number.
	Work_title string `xml:"work-title,omitempty" json:"work-title,omitempty"`

	Opus *Opus `xml:"opus,omitempty" json:"opus,omitempty"`
}

func CopyBranchWork 

func CopyBranchWork(mapOrigCopy map[any]any, workFrom *Work) (workTo *Work)

func (*Work) Checkout 

func (work *Work) Checkout(stage *StageStruct) *Work

Checkout work to the back repo (if it is already staged)

func (*Work) Commit 

func (work *Work) Commit(stage *StageStruct) *Work

commit work to the back repo (if it is already staged)

func (*Work) CommitVoid 

func (work *Work) CommitVoid(stage *StageStruct)

func (*Work) CopyBasicFields 

func (from *Work) CopyBasicFields(to *Work)

func (*Work) GetName 

func (work *Work) GetName() (res string)

for satisfaction of GongStruct interface

func (*Work) Stage 

func (work *Work) Stage(stage *StageStruct) *Work

Stage puts work to the model stage

func (*Work) Unstage 

func (work *Work) Unstage(stage *StageStruct) *Work

Unstage removes work off the model stage

func (*Work) UnstageVoid 

func (work *Work) UnstageVoid(stage *StageStruct)

UnstageVoid removes work off the model stage

type Work_WOP 

type Work_WOP struct {
	// insertion point
	Name        string
	Work_number string
	Work_title  string
}

type Yes_no 

type Yes_no string
const (
	Yes_noYes Yes_no = "yes"

	Yes_noNo Yes_no = "no"
)

func (Yes_no) CodeValues 

func (yes_no Yes_no) CodeValues() (res []string)

func (Yes_no) Codes 

func (yes_no Yes_no) Codes() (res []string)

func (*Yes_no) FromCodeString 

func (yes_no *Yes_no) FromCodeString(input string) (err error)

func (*Yes_no) FromString 

func (yes_no *Yes_no) FromString(input string) (err error)

func (*Yes_no) ToCodeString 

func (yes_no *Yes_no) ToCodeString() (res string)

func (Yes_no) ToString 

func (yes_no Yes_no) ToString() (res string)

Utility function for Yes_no if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Yes_no_number 

type Yes_no_number string

func (Yes_no_number) CodeValues 

func (yes_no_number Yes_no_number) CodeValues() (res []string)

func (Yes_no_number) Codes 

func (yes_no_number Yes_no_number) Codes() (res []string)

func (*Yes_no_number) FromCodeString 

func (yes_no_number *Yes_no_number) FromCodeString(input string) (err error)

func (*Yes_no_number) FromString 

func (yes_no_number *Yes_no_number) FromString(input string) (err error)

func (*Yes_no_number) ToCodeString 

func (yes_no_number *Yes_no_number) ToCodeString() (res string)

func (Yes_no_number) ToString 

func (yes_no_number Yes_no_number) ToString() (res string)

Utility function for Yes_no_number if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Yyyy_mm_dd 

type Yyyy_mm_dd soap.XSDDate

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.