models

type AllModelsStructCreateInterface interface {
	CreateORMFreqency(Freqency *Freqency)
	CreateORMNote(Note *Note)
	CreateORMPlayer(Player *Player)
}

type AllModelsStructDeleteInterface interface {
	DeleteORMFreqency(Freqency *Freqency)
	DeleteORMNote(Note *Note)
	DeleteORMPlayer(Player *Player)
}

type BackRepoInterface interface {
	Commit(stage *Stage)
	Checkout(stage *Stage)
	Backup(stage *Stage, dirPath string)
	Restore(stage *Stage, dirPath string)
	BackupXL(stage *Stage, dirPath string)
	RestoreXL(stage *Stage, dirPath string)
	// insertion point for Commit and Checkout signatures
	CommitFreqency(freqency *Freqency)
	CheckoutFreqency(freqency *Freqency)
	CommitNote(note *Note)
	CheckoutNote(note *Note)
	CommitPlayer(player *Player)
	CheckoutPlayer(player *Player)
	GetLastCommitFromBackNb() uint
	GetLastPushFromFrontNb() uint
}

type ExcelizeTabulator struct {
	// contains filtered or unexported fields
}

type Freqency struct {
	Name string
}

type Freqency_WOP struct {
	// insertion point
	Name string
}

type GONG__ExpressionType string

type GONG__Identifier struct {
	Ident string
	Type  GONG__ExpressionType
}

type GongFieldValue struct {
	GongFieldValueType
	// contains filtered or unexported fields
}

type GongFieldValueType string

type GongStructInterface interface {
	GetName() (res string)
}

type Gongstruct interface {
}

type GongstructEnumIntField interface {
	int
	Codes() []string
	CodeValues() []int
}

type GongstructEnumStringField interface {
	Codes() []string
	CodeValues() []string
	ToString() string
}

type GongstructMapString interface {
	map[any]any
}

type GongstructSet interface {
	map[any]any
}

type GongtructBasicField interface {
	int | float64 | bool | string | time.Time | time.Duration
}

type NamedStruct struct {
	// contains filtered or unexported fields
}

type Note struct {
	Name string

	Frequencies []*Freqency

	Start float64

	Duration float64

	Velocity float64

	// to help to decode
	Info string
}

type Note_WOP struct {
	// insertion point
	Name     string
	Start    float64
	Duration float64
	Velocity float64
	Info     string
}

type OnAfterCreateInterface[Type Gongstruct] interface {
	OnAfterCreate(stage *Stage,
		instance *Type)
}

type OnAfterDeleteInterface[Type Gongstruct] interface {
	OnAfterDelete(stage *Stage,
		staged, front *Type)
}

type OnAfterReadInterface[Type Gongstruct] interface {
	OnAfterRead(stage *Stage,
		instance *Type)
}

type OnAfterUpdateInterface[Type Gongstruct] interface {
	OnAfterUpdate(stage *Stage, old, new *Type)
}

type OnInitCommitInterface interface {
	BeforeCommit(stage *Stage)
}

type Player struct {
	Name string

	Status Status

	// DI contains a dependency injection callback
	OnDI func(*Player) error
}

type PlayerOrchestrator struct {
}

type Player_WOP struct {
	// insertion point
	Name   string
	Status Status
}

type PointerToGongstruct interface {
	GetName() string
	CommitVoid(*Stage)
	UnstageVoid(stage *Stage)
	comparable
}

type PointerToGongstructEnumIntField interface {
	FromCodeString(input string) (err error)
}

type PointerToGongstructEnumStringField interface {
	FromCodeString(input string) (err error)
}

type ReverseField struct {
	GongstructName string
	Fieldname      string
}

type Stage struct {

	// insertion point for definition of arrays registering instances
	Freqencys           map[*Freqency]any
	Freqencys_mapString map[string]*Freqency

	// insertion point for slice of pointers maps
	OnAfterFreqencyCreateCallback OnAfterCreateInterface[Freqency]
	OnAfterFreqencyUpdateCallback OnAfterUpdateInterface[Freqency]
	OnAfterFreqencyDeleteCallback OnAfterDeleteInterface[Freqency]
	OnAfterFreqencyReadCallback   OnAfterReadInterface[Freqency]

	Notes           map[*Note]any
	Notes_mapString map[string]*Note

	// insertion point for slice of pointers maps
	Note_Frequencies_reverseMap map[*Freqency]*Note

	OnAfterNoteCreateCallback OnAfterCreateInterface[Note]
	OnAfterNoteUpdateCallback OnAfterUpdateInterface[Note]
	OnAfterNoteDeleteCallback OnAfterDeleteInterface[Note]
	OnAfterNoteReadCallback   OnAfterReadInterface[Note]

	Players           map[*Player]any
	Players_mapString map[string]*Player

	// insertion point for slice of pointers maps
	OnAfterPlayerCreateCallback OnAfterCreateInterface[Player]
	OnAfterPlayerUpdateCallback OnAfterUpdateInterface[Player]
	OnAfterPlayerDeleteCallback OnAfterDeleteInterface[Player]
	OnAfterPlayerReadCallback   OnAfterReadInterface[Player]

	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

	// store the stage order of each instance in order to
	// preserve this order when serializing them
	// insertion point for order fields declaration
	FreqencyOrder            uint
	FreqencyMap_Staged_Order map[*Freqency]uint

	NoteOrder            uint
	NoteMap_Staged_Order map[*Note]uint

	PlayerOrder            uint
	PlayerMap_Staged_Order map[*Player]uint

	NamedStructs []*NamedStruct
	// contains filtered or unexported fields
}

type Stager struct {
	// contains filtered or unexported fields
}

type Status string

type Tabulator interface {
	AddSheet(sheetName string)
	AddRow(sheetName string) int
	AddCell(sheetName string, rowId, columnIndex int, value string)
}