models

type AllModelsStructCreateInterface interface {
	CreateORMBody(Body *Body)
	CreateORMDocument(Document *Document)
	CreateORMDocx(Docx *Docx)
	CreateORMFile(File *File)
	CreateORMNode(Node *Node)
	CreateORMParagraph(Paragraph *Paragraph)
	CreateORMParagraphProperties(ParagraphProperties *ParagraphProperties)
	CreateORMParagraphStyle(ParagraphStyle *ParagraphStyle)
	CreateORMRune(Rune *Rune)
	CreateORMRuneProperties(RuneProperties *RuneProperties)
	CreateORMTable(Table *Table)
	CreateORMTableColumn(TableColumn *TableColumn)
	CreateORMTableProperties(TableProperties *TableProperties)
	CreateORMTableRow(TableRow *TableRow)
	CreateORMTableStyle(TableStyle *TableStyle)
	CreateORMText(Text *Text)
}

type AllModelsStructDeleteInterface interface {
	DeleteORMBody(Body *Body)
	DeleteORMDocument(Document *Document)
	DeleteORMDocx(Docx *Docx)
	DeleteORMFile(File *File)
	DeleteORMNode(Node *Node)
	DeleteORMParagraph(Paragraph *Paragraph)
	DeleteORMParagraphProperties(ParagraphProperties *ParagraphProperties)
	DeleteORMParagraphStyle(ParagraphStyle *ParagraphStyle)
	DeleteORMRune(Rune *Rune)
	DeleteORMRuneProperties(RuneProperties *RuneProperties)
	DeleteORMTable(Table *Table)
	DeleteORMTableColumn(TableColumn *TableColumn)
	DeleteORMTableProperties(TableProperties *TableProperties)
	DeleteORMTableRow(TableRow *TableRow)
	DeleteORMTableStyle(TableStyle *TableStyle)
	DeleteORMText(Text *Text)
}

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
	CommitBody(body *Body)
	CheckoutBody(body *Body)
	CommitDocument(document *Document)
	CheckoutDocument(document *Document)
	CommitDocx(docx *Docx)
	CheckoutDocx(docx *Docx)
	CommitFile(file *File)
	CheckoutFile(file *File)
	CommitNode(node *Node)
	CheckoutNode(node *Node)
	CommitParagraph(paragraph *Paragraph)
	CheckoutParagraph(paragraph *Paragraph)
	CommitParagraphProperties(paragraphproperties *ParagraphProperties)
	CheckoutParagraphProperties(paragraphproperties *ParagraphProperties)
	CommitParagraphStyle(paragraphstyle *ParagraphStyle)
	CheckoutParagraphStyle(paragraphstyle *ParagraphStyle)
	CommitRune(rune *Rune)
	CheckoutRune(rune *Rune)
	CommitRuneProperties(runeproperties *RuneProperties)
	CheckoutRuneProperties(runeproperties *RuneProperties)
	CommitTable(table *Table)
	CheckoutTable(table *Table)
	CommitTableColumn(tablecolumn *TableColumn)
	CheckoutTableColumn(tablecolumn *TableColumn)
	CommitTableProperties(tableproperties *TableProperties)
	CheckoutTableProperties(tableproperties *TableProperties)
	CommitTableRow(tablerow *TableRow)
	CheckoutTableRow(tablerow *TableRow)
	CommitTableStyle(tablestyle *TableStyle)
	CheckoutTableStyle(tablestyle *TableStyle)
	CommitText(text *Text)
	CheckoutText(text *Text)
	GetLastCommitFromBackNb() uint
	GetLastPushFromFrontNb() uint
}

type Body struct {
	Name       string
	Paragraphs []*Paragraph
	Tables     []*Table

	// for enabling navigation between paragraphs
	LastParagraph *Paragraph
}

type Body_WOP struct {
	// insertion point
	Name string
}

type Document struct {
	Name string
	File *File
	Root *Node
	Body *Body
}

type Document_WOP struct {
	// insertion point
	Name string
}

type Docx struct {
	Name string

	Files []*File

	Document *Document
}

type Docx_WOP struct {
	// insertion point
	Name string
}

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

type File struct {
	Name string
}

type File_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 Node struct {
	Name string

	Nodes []*Node
}

type Node_ struct {
	XMLName xml.Name
	Attrs   []xml.Attr `xml:"-"`
	Content []byte     `xml:",innerxml"`
	Nodes   []Node_    `xml:",any"`
}

type Node_WOP struct {
	// insertion point
	Name string
}

type Numbering struct {
	XMLName     xml.Name `xml:"numbering"`
	Text        string   `xml:",chardata"`
	Wpc         string   `xml:"wpc,attr"`
	Cx          string   `xml:"cx,attr"`
	Cx1         string   `xml:"cx1,attr"`
	Mc          string   `xml:"mc,attr"`
	O           string   `xml:"o,attr"`
	R           string   `xml:"r,attr"`
	M           string   `xml:"m,attr"`
	V           string   `xml:"v,attr"`
	Wp14        string   `xml:"wp14,attr"`
	Wp          string   `xml:"wp,attr"`
	W10         string   `xml:"w10,attr"`
	W           string   `xml:"w,attr"`
	W14         string   `xml:"w14,attr"`
	W15         string   `xml:"w15,attr"`
	W16se       string   `xml:"w16se,attr"`
	Wpg         string   `xml:"wpg,attr"`
	Wpi         string   `xml:"wpi,attr"`
	Wne         string   `xml:"wne,attr"`
	Wps         string   `xml:"wps,attr"`
	Ignorable   string   `xml:"Ignorable,attr"`
	AbstractNum []struct {
		Text                       string         `xml:",chardata"`
		AbstractNumID              string         `xml:"abstractNumId,attr"`
		RestartNumberingAfterBreak string         `xml:"restartNumberingAfterBreak,attr"`
		Nsid                       TextVal        `xml:"nsid"`
		MultiLevelType             TextVal        `xml:"multiLevelType"`
		Tmpl                       TextVal        `xml:"tmpl"`
		Lvl                        []NumberingLvl `xml:"lvl"`
	} `xml:"abstractNum"`
	Num []struct {
		Text          string  `xml:",chardata"`
		NumID         string  `xml:"numId,attr"`
		AbstractNumID TextVal `xml:"abstractNumId"`
	} `xml:"num"`
}

type NumberingLvl struct {
	Text      string  `xml:",chardata"`
	Ilvl      string  `xml:"ilvl,attr"`
	Tplc      string  `xml:"tplc,attr"`
	Tentative string  `xml:"tentative,attr"`
	Start     TextVal `xml:"start"`
	NumFmt    TextVal `xml:"numFmt"`
	LvlText   TextVal `xml:"lvlText"`
	LvlJc     TextVal `xml:"lvlJc"`
	PPr       struct {
		Text string `xml:",chardata"`
		Ind  struct {
			Text    string `xml:",chardata"`
			Left    string `xml:"left,attr"`
			Hanging string `xml:"hanging,attr"`
		} `xml:"ind"`
	} `xml:"pPr"`
	RPr struct {
		Text string `xml:",chardata"`
		U    struct {
			Text string `xml:",chardata"`
			Val  string `xml:"val,attr"`
		} `xml:"u"`
		RFonts struct {
			Text string `xml:",chardata"`
			Hint string `xml:"hint,attr"`
		} `xml:"rFonts"`
	} `xml:"rPr"`
}

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

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

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

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

type OnInitCommitInterface interface {
	BeforeCommit(stage *StageStruct)
}

type Paragraph struct {
	Name                string
	Content             string
	Node                *Node
	ParagraphProperties *ParagraphProperties
	Runes               []*Rune

	Text string // collated text of all runes

	// navigation
	Next                 *Paragraph
	Previous             *Paragraph
	EnclosingBody        *Body
	EnclosingTableColumn *TableColumn
}

type ParagraphProperties struct {
	Name    string
	Content string

	ParagraphStyle *ParagraphStyle

	Node *Node
}

type ParagraphProperties_WOP struct {
	// insertion point
	Name    string
	Content string
}

type ParagraphStyle struct {
	Name    string
	Node    *Node
	Content string

	// 	The "w:val" attribute in WordProcessingML stores a value for a specific
	// property. For "w:pStyle", "w:val" holds the ID of the paragraph style applied
	// to the current paragraph.
	//
	// "w" stands for the Word namespace, a standard in WordProcessingML to avoid
	// naming conflicts with other XML languages. "val" is likely short for "value,"
	// indicating this attribute holds the value of the "w:pStyle" element.
	//
	// Thus, "w:val" holds a value in the Word namespace. Its specific meaning can
	// vary depending on context, but it often holds an ID linking to other data or
	// formatting in the .docx package.
	ValAttr string
}

type ParagraphStyle_WOP struct {
	// insertion point
	Name    string
	Content string
	ValAttr string
}

type Paragraph_WOP struct {
	// insertion point
	Name    string
	Content string
	Text    string
}

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

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

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

type Relationship struct {
	Text       string `xml:",chardata"`
	ID         string `xml:"Id,attr"`
	Type       string `xml:"Type,attr"`
	Target     string `xml:"Target,attr"`
	TargetMode string `xml:"TargetMode,attr"`
}

type Relationships struct {
	XMLName      xml.Name       `xml:"Relationships"`
	Text         string         `xml:",chardata"`
	Xmlns        string         `xml:"xmlns,attr"`
	Relationship []Relationship `xml:"Relationship"`
}

type ReverseField struct {
	GongstructName string
	Fieldname      string
}

type Rune struct {
	Name    string
	Content string

	Node           *Node
	Text           *Text
	RuneProperties *RuneProperties

	// navigation
	EnclosingParagraph *Paragraph
}

type RuneProperties struct {
	Name     string
	Node     *Node
	IsBold   bool
	IsStrike bool
	IsItalic bool

	Content string
}

type RuneProperties_WOP struct {
	// insertion point
	Name     string
	IsBold   bool
	IsStrike bool
	IsItalic bool
	Content  string
}

type Rune_WOP struct {
	// insertion point
	Name    string
	Content string
}

type StageStruct struct {

	// insertion point for definition of arrays registering instances
	Bodys           map[*Body]any
	Bodys_mapString map[string]*Body

	// insertion point for slice of pointers maps
	Body_Paragraphs_reverseMap map[*Paragraph]*Body

	Body_Tables_reverseMap map[*Table]*Body

	OnAfterBodyCreateCallback OnAfterCreateInterface[Body]
	OnAfterBodyUpdateCallback OnAfterUpdateInterface[Body]
	OnAfterBodyDeleteCallback OnAfterDeleteInterface[Body]
	OnAfterBodyReadCallback   OnAfterReadInterface[Body]

	Documents           map[*Document]any
	Documents_mapString map[string]*Document

	// insertion point for slice of pointers maps
	OnAfterDocumentCreateCallback OnAfterCreateInterface[Document]
	OnAfterDocumentUpdateCallback OnAfterUpdateInterface[Document]
	OnAfterDocumentDeleteCallback OnAfterDeleteInterface[Document]
	OnAfterDocumentReadCallback   OnAfterReadInterface[Document]

	Docxs           map[*Docx]any
	Docxs_mapString map[string]*Docx

	// insertion point for slice of pointers maps
	Docx_Files_reverseMap map[*File]*Docx

	OnAfterDocxCreateCallback OnAfterCreateInterface[Docx]
	OnAfterDocxUpdateCallback OnAfterUpdateInterface[Docx]
	OnAfterDocxDeleteCallback OnAfterDeleteInterface[Docx]
	OnAfterDocxReadCallback   OnAfterReadInterface[Docx]

	Files           map[*File]any
	Files_mapString map[string]*File

	// insertion point for slice of pointers maps
	OnAfterFileCreateCallback OnAfterCreateInterface[File]
	OnAfterFileUpdateCallback OnAfterUpdateInterface[File]
	OnAfterFileDeleteCallback OnAfterDeleteInterface[File]
	OnAfterFileReadCallback   OnAfterReadInterface[File]

	Nodes           map[*Node]any
	Nodes_mapString map[string]*Node

	// insertion point for slice of pointers maps
	Node_Nodes_reverseMap map[*Node]*Node

	OnAfterNodeCreateCallback OnAfterCreateInterface[Node]
	OnAfterNodeUpdateCallback OnAfterUpdateInterface[Node]
	OnAfterNodeDeleteCallback OnAfterDeleteInterface[Node]
	OnAfterNodeReadCallback   OnAfterReadInterface[Node]

	Paragraphs           map[*Paragraph]any
	Paragraphs_mapString map[string]*Paragraph

	// insertion point for slice of pointers maps
	Paragraph_Runes_reverseMap map[*Rune]*Paragraph

	OnAfterParagraphCreateCallback OnAfterCreateInterface[Paragraph]
	OnAfterParagraphUpdateCallback OnAfterUpdateInterface[Paragraph]
	OnAfterParagraphDeleteCallback OnAfterDeleteInterface[Paragraph]
	OnAfterParagraphReadCallback   OnAfterReadInterface[Paragraph]

	ParagraphPropertiess           map[*ParagraphProperties]any
	ParagraphPropertiess_mapString map[string]*ParagraphProperties

	// insertion point for slice of pointers maps
	OnAfterParagraphPropertiesCreateCallback OnAfterCreateInterface[ParagraphProperties]
	OnAfterParagraphPropertiesUpdateCallback OnAfterUpdateInterface[ParagraphProperties]
	OnAfterParagraphPropertiesDeleteCallback OnAfterDeleteInterface[ParagraphProperties]
	OnAfterParagraphPropertiesReadCallback   OnAfterReadInterface[ParagraphProperties]

	ParagraphStyles           map[*ParagraphStyle]any
	ParagraphStyles_mapString map[string]*ParagraphStyle

	// insertion point for slice of pointers maps
	OnAfterParagraphStyleCreateCallback OnAfterCreateInterface[ParagraphStyle]
	OnAfterParagraphStyleUpdateCallback OnAfterUpdateInterface[ParagraphStyle]
	OnAfterParagraphStyleDeleteCallback OnAfterDeleteInterface[ParagraphStyle]
	OnAfterParagraphStyleReadCallback   OnAfterReadInterface[ParagraphStyle]

	Runes           map[*Rune]any
	Runes_mapString map[string]*Rune

	// insertion point for slice of pointers maps
	OnAfterRuneCreateCallback OnAfterCreateInterface[Rune]
	OnAfterRuneUpdateCallback OnAfterUpdateInterface[Rune]
	OnAfterRuneDeleteCallback OnAfterDeleteInterface[Rune]
	OnAfterRuneReadCallback   OnAfterReadInterface[Rune]

	RunePropertiess           map[*RuneProperties]any
	RunePropertiess_mapString map[string]*RuneProperties

	// insertion point for slice of pointers maps
	OnAfterRunePropertiesCreateCallback OnAfterCreateInterface[RuneProperties]
	OnAfterRunePropertiesUpdateCallback OnAfterUpdateInterface[RuneProperties]
	OnAfterRunePropertiesDeleteCallback OnAfterDeleteInterface[RuneProperties]
	OnAfterRunePropertiesReadCallback   OnAfterReadInterface[RuneProperties]

	Tables           map[*Table]any
	Tables_mapString map[string]*Table

	// insertion point for slice of pointers maps
	Table_TableRows_reverseMap map[*TableRow]*Table

	OnAfterTableCreateCallback OnAfterCreateInterface[Table]
	OnAfterTableUpdateCallback OnAfterUpdateInterface[Table]
	OnAfterTableDeleteCallback OnAfterDeleteInterface[Table]
	OnAfterTableReadCallback   OnAfterReadInterface[Table]

	TableColumns           map[*TableColumn]any
	TableColumns_mapString map[string]*TableColumn

	// insertion point for slice of pointers maps
	TableColumn_Paragraphs_reverseMap map[*Paragraph]*TableColumn

	OnAfterTableColumnCreateCallback OnAfterCreateInterface[TableColumn]
	OnAfterTableColumnUpdateCallback OnAfterUpdateInterface[TableColumn]
	OnAfterTableColumnDeleteCallback OnAfterDeleteInterface[TableColumn]
	OnAfterTableColumnReadCallback   OnAfterReadInterface[TableColumn]

	TablePropertiess           map[*TableProperties]any
	TablePropertiess_mapString map[string]*TableProperties

	// insertion point for slice of pointers maps
	OnAfterTablePropertiesCreateCallback OnAfterCreateInterface[TableProperties]
	OnAfterTablePropertiesUpdateCallback OnAfterUpdateInterface[TableProperties]
	OnAfterTablePropertiesDeleteCallback OnAfterDeleteInterface[TableProperties]
	OnAfterTablePropertiesReadCallback   OnAfterReadInterface[TableProperties]

	TableRows           map[*TableRow]any
	TableRows_mapString map[string]*TableRow

	// insertion point for slice of pointers maps
	TableRow_TableColumns_reverseMap map[*TableColumn]*TableRow

	OnAfterTableRowCreateCallback OnAfterCreateInterface[TableRow]
	OnAfterTableRowUpdateCallback OnAfterUpdateInterface[TableRow]
	OnAfterTableRowDeleteCallback OnAfterDeleteInterface[TableRow]
	OnAfterTableRowReadCallback   OnAfterReadInterface[TableRow]

	TableStyles           map[*TableStyle]any
	TableStyles_mapString map[string]*TableStyle

	// insertion point for slice of pointers maps
	OnAfterTableStyleCreateCallback OnAfterCreateInterface[TableStyle]
	OnAfterTableStyleUpdateCallback OnAfterUpdateInterface[TableStyle]
	OnAfterTableStyleDeleteCallback OnAfterDeleteInterface[TableStyle]
	OnAfterTableStyleReadCallback   OnAfterReadInterface[TableStyle]

	Texts           map[*Text]any
	Texts_mapString map[string]*Text

	// insertion point for slice of pointers maps
	OnAfterTextCreateCallback OnAfterCreateInterface[Text]
	OnAfterTextUpdateCallback OnAfterUpdateInterface[Text]
	OnAfterTextDeleteCallback OnAfterDeleteInterface[Text]
	OnAfterTextReadCallback   OnAfterReadInterface[Text]

	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
}

type Table struct {
	Name            string
	Node            *Node
	Content         string
	TableProperties *TableProperties
	TableRows       []*TableRow
}

type TableColumn struct {
	Name       string
	Content    string
	Node       *Node
	Paragraphs []*Paragraph
}

type TableColumn_WOP struct {
	// insertion point
	Name    string
	Content string
}

type TableProperties struct {
	Name       string
	Node       *Node
	Content    string
	TableStyle *TableStyle
}

type TableProperties_WOP struct {
	// insertion point
	Name    string
	Content string
}

type TableRow struct {
	Name         string
	Content      string
	Node         *Node
	TableColumns []*TableColumn
}

type TableRow_WOP struct {
	// insertion point
	Name    string
	Content string
}

type TableStyle struct {
	Name    string
	Node    *Node
	Content string
	Val     string
}

type TableStyle_WOP struct {
	// insertion point
	Name    string
	Content string
	Val     string
}

type Table_WOP struct {
	// insertion point
	Name    string
	Content string
}

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

type Text struct {
	Name               string
	Content            string
	Node               *Node
	PreserveWhiteSpace bool

	// navigation
	EnclosingRune *Rune
}

type TextVal struct {
	Text string `xml:",chardata"`
	Val  string `xml:"val,attr"`
}

type Text_WOP struct {
	// insertion point
	Name               string
	Content            string
	PreserveWhiteSpace bool
}