models

type AllModelsStructCreateInterface interface {
	CreateORMCell(Cell *Cell)
	CreateORMCellBoolean(CellBoolean *CellBoolean)
	CreateORMCellFloat64(CellFloat64 *CellFloat64)
	CreateORMCellIcon(CellIcon *CellIcon)
	CreateORMCellInt(CellInt *CellInt)
	CreateORMCellString(CellString *CellString)
	CreateORMCheckBox(CheckBox *CheckBox)
	CreateORMDisplayedColumn(DisplayedColumn *DisplayedColumn)
	CreateORMFormDiv(FormDiv *FormDiv)
	CreateORMFormEditAssocButton(FormEditAssocButton *FormEditAssocButton)
	CreateORMFormField(FormField *FormField)
	CreateORMFormFieldDate(FormFieldDate *FormFieldDate)
	CreateORMFormFieldDateTime(FormFieldDateTime *FormFieldDateTime)
	CreateORMFormFieldFloat64(FormFieldFloat64 *FormFieldFloat64)
	CreateORMFormFieldInt(FormFieldInt *FormFieldInt)
	CreateORMFormFieldSelect(FormFieldSelect *FormFieldSelect)
	CreateORMFormFieldString(FormFieldString *FormFieldString)
	CreateORMFormFieldTime(FormFieldTime *FormFieldTime)
	CreateORMFormGroup(FormGroup *FormGroup)
	CreateORMFormSortAssocButton(FormSortAssocButton *FormSortAssocButton)
	CreateORMOption(Option *Option)
	CreateORMRow(Row *Row)
	CreateORMTable(Table *Table)
}

type AllModelsStructDeleteInterface interface {
	DeleteORMCell(Cell *Cell)
	DeleteORMCellBoolean(CellBoolean *CellBoolean)
	DeleteORMCellFloat64(CellFloat64 *CellFloat64)
	DeleteORMCellIcon(CellIcon *CellIcon)
	DeleteORMCellInt(CellInt *CellInt)
	DeleteORMCellString(CellString *CellString)
	DeleteORMCheckBox(CheckBox *CheckBox)
	DeleteORMDisplayedColumn(DisplayedColumn *DisplayedColumn)
	DeleteORMFormDiv(FormDiv *FormDiv)
	DeleteORMFormEditAssocButton(FormEditAssocButton *FormEditAssocButton)
	DeleteORMFormField(FormField *FormField)
	DeleteORMFormFieldDate(FormFieldDate *FormFieldDate)
	DeleteORMFormFieldDateTime(FormFieldDateTime *FormFieldDateTime)
	DeleteORMFormFieldFloat64(FormFieldFloat64 *FormFieldFloat64)
	DeleteORMFormFieldInt(FormFieldInt *FormFieldInt)
	DeleteORMFormFieldSelect(FormFieldSelect *FormFieldSelect)
	DeleteORMFormFieldString(FormFieldString *FormFieldString)
	DeleteORMFormFieldTime(FormFieldTime *FormFieldTime)
	DeleteORMFormGroup(FormGroup *FormGroup)
	DeleteORMFormSortAssocButton(FormSortAssocButton *FormSortAssocButton)
	DeleteORMOption(Option *Option)
	DeleteORMRow(Row *Row)
	DeleteORMTable(Table *Table)
}

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
	CommitCell(cell *Cell)
	CheckoutCell(cell *Cell)
	CommitCellBoolean(cellboolean *CellBoolean)
	CheckoutCellBoolean(cellboolean *CellBoolean)
	CommitCellFloat64(cellfloat64 *CellFloat64)
	CheckoutCellFloat64(cellfloat64 *CellFloat64)
	CommitCellIcon(cellicon *CellIcon)
	CheckoutCellIcon(cellicon *CellIcon)
	CommitCellInt(cellint *CellInt)
	CheckoutCellInt(cellint *CellInt)
	CommitCellString(cellstring *CellString)
	CheckoutCellString(cellstring *CellString)
	CommitCheckBox(checkbox *CheckBox)
	CheckoutCheckBox(checkbox *CheckBox)
	CommitDisplayedColumn(displayedcolumn *DisplayedColumn)
	CheckoutDisplayedColumn(displayedcolumn *DisplayedColumn)
	CommitFormDiv(formdiv *FormDiv)
	CheckoutFormDiv(formdiv *FormDiv)
	CommitFormEditAssocButton(formeditassocbutton *FormEditAssocButton)
	CheckoutFormEditAssocButton(formeditassocbutton *FormEditAssocButton)
	CommitFormField(formfield *FormField)
	CheckoutFormField(formfield *FormField)
	CommitFormFieldDate(formfielddate *FormFieldDate)
	CheckoutFormFieldDate(formfielddate *FormFieldDate)
	CommitFormFieldDateTime(formfielddatetime *FormFieldDateTime)
	CheckoutFormFieldDateTime(formfielddatetime *FormFieldDateTime)
	CommitFormFieldFloat64(formfieldfloat64 *FormFieldFloat64)
	CheckoutFormFieldFloat64(formfieldfloat64 *FormFieldFloat64)
	CommitFormFieldInt(formfieldint *FormFieldInt)
	CheckoutFormFieldInt(formfieldint *FormFieldInt)
	CommitFormFieldSelect(formfieldselect *FormFieldSelect)
	CheckoutFormFieldSelect(formfieldselect *FormFieldSelect)
	CommitFormFieldString(formfieldstring *FormFieldString)
	CheckoutFormFieldString(formfieldstring *FormFieldString)
	CommitFormFieldTime(formfieldtime *FormFieldTime)
	CheckoutFormFieldTime(formfieldtime *FormFieldTime)
	CommitFormGroup(formgroup *FormGroup)
	CheckoutFormGroup(formgroup *FormGroup)
	CommitFormSortAssocButton(formsortassocbutton *FormSortAssocButton)
	CheckoutFormSortAssocButton(formsortassocbutton *FormSortAssocButton)
	CommitOption(option *Option)
	CheckoutOption(option *Option)
	CommitRow(row *Row)
	CheckoutRow(row *Row)
	CommitTable(table *Table)
	CheckoutTable(table *Table)
	GetLastCommitFromBackNb() uint
	GetLastPushFromFrontNb() uint
}

type Cell struct {
	Name string

	CellString  *CellString
	CellFloat64 *CellFloat64
	CellInt     *CellInt
	CellBool    *CellBoolean
	CellIcon    *CellIcon
}

type CellBoolean struct {
	Name  string
	Value bool
}

type CellBoolean_WOP struct {
	Name string

	Value bool
}

type CellFloat64 struct {
	Name  string
	Value float64
}

type CellFloat64_WOP struct {
	Name string

	Value float64
}

type CellIcon struct {
	Name string

	// reference of the material icon (ex "home", "delete", "edit")
	Icon string

	// needs confirmation ? (for instance if the icon is a delete icon)
	NeedsConfirmation   bool
	ConfirmationMessage string

	// swagger:ignore
	Impl CellIconImplInterface
}

type CellIconImplInterface interface {

	// CellIconUpdated function is called each time a CellIcon is modified
	CellIconUpdated(stage *Stage, cellIcon, updatedCellIcon *CellIcon)
}

type CellIconOrchestrator struct {
}

type CellIcon_WOP struct {
	Name string

	Icon string

	NeedsConfirmation bool

	ConfirmationMessage string
}

type CellInt struct {
	Name  string
	Value int
}

type CellInt_WOP struct {
	Name string

	Value int
}

type CellString struct {
	Name  string
	Value string
}

type CellString_WOP struct {
	Name string

	Value string
}

type Cell_WOP struct {
	Name string
}

type CheckBox struct {
	Name  string
	Value bool
}

type CheckBox_WOP struct {
	Name string

	Value bool
}

type DiffHunk struct {
	OldStart int
	OldLines int
	NewStart int
	NewLines int
	Lines    []string
}

type DiffOp struct {
	Type string // "context", "delete", "add"
	Text string
}

type DisplayedColumn struct {
	Name string
}

type DisplayedColumn_WOP struct {
	Name string
}

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

type FormDiv struct {
	Name                string
	FormFields          []*FormField
	CheckBoxs           []*CheckBox
	FormEditAssocButton *FormEditAssocButton
	FormSortAssocButton *FormSortAssocButton
}

type FormDiv_WOP struct {
	Name string
}

type FormEditAssocButton struct {
	Name string

	Label string

	// AssociationStorage is the encoding into a string of the IDs of the associatied instances
	// the format is json
	AssociationStorage string

	// HasChanged is true when the end user has used this form
	// When true, the instance will be updated to the back
	HasChanged bool

	// IsForSavePurpose is true when the FormEditAssocButton is updated
	// by the submit of the front (it is false when the button is pressed)
	IsForSavePurpose bool

	// swagger:ignore
	OnAssocEditon FormEditAssocButtonInterface

	HasToolTip  bool
	ToolTipText string
}

type FormEditAssocButtonInterface interface {
	OnButtonPressed()
}

type FormEditAssocButtonOrchestrator struct {
}

type FormEditAssocButton_WOP struct {
	Name string

	Label string

	AssociationStorage string

	HasChanged bool

	IsForSavePurpose bool

	HasToolTip bool

	ToolTipText string
}

type FormField struct {
	Name          string
	InputTypeEnum InputTypeEnum

	// label for the input field.
	// for instance "First Name" in <mat-label>First Name</mat-label>
	Label string

	// suggestion for the field
	Placeholder string

	FormFieldString  *FormFieldString
	FormFieldFloat64 *FormFieldFloat64
	FormFieldInt     *FormFieldInt

	FormFieldDate     *FormFieldDate
	FormFieldTime     *FormFieldTime
	FormFieldDateTime *FormFieldDateTime

	FormFieldSelect *FormFieldSelect

	// set up specific width
	HasBespokeWidth bool
	BespokeWidthPx  int

	// set up specific height
	HasBespokeHeight bool
	BespokeHeightPx  int
}

type FormFieldDate struct {
	Name string

	// we will only update the day
	Value time.Time
}

type FormFieldDateTime struct {
	Name string

	Value time.Time
}

type FormFieldDateTime_WOP struct {
	Name string

	Value time.Time
}

type FormFieldDate_WOP struct {
	Name string

	Value time.Time
}

type FormFieldFloat64 struct {
	Name  string
	Value float64

	HasMinValidator bool
	MinValue        float64

	HasMaxValidator bool
	MaxValue        float64
}

type FormFieldFloat64_WOP struct {
	Name string

	Value float64

	HasMinValidator bool

	MinValue float64

	HasMaxValidator bool

	MaxValue float64
}

type FormFieldInt struct {
	Name  string
	Value int

	HasMinValidator bool
	MinValue        int

	HasMaxValidator bool
	MaxValue        int
}

type FormFieldInt_WOP struct {
	Name string

	Value int

	HasMinValidator bool

	MinValue int

	HasMaxValidator bool

	MaxValue int
}

type FormFieldSelect struct {
	Name  string
	Value *Option

	Options []*Option

	CanBeEmpty bool

	// PreserveInitialOrder overides default alphabetical
	// ordering of Options in the pulldown menu
	PreserveInitialOrder bool
}

type FormFieldSelect_WOP struct {
	Name string

	CanBeEmpty bool

	PreserveInitialOrder bool
}

type FormFieldString struct {
	Name  string
	Value string

	// IsTextArea is for telling angular whether to put a, <input ..> or a <textarea ..> which
	// allows for multi text editing
	IsTextArea bool
}

type FormFieldString_WOP struct {
	Name string

	Value string

	IsTextArea bool
}

type FormFieldTime struct {
	Name string

	// we will only update the hours, minutes, seconds, ...
	Value time.Time

	// For an <input> element with type="time",
	// the step attribute determines the step size between time values. Its value is specified in seconds.
	// When you set step="1", it means the smallest interval of time the user can select or input is one second.
	//  This allows users to pick any time down to the second. If you omit the step attribute or set it to
	// a value like 60 (which corresponds to one minute), users can only pick times in one-minute intervals.
	//
	// For type="time", it determines the step between times.
	// If you want granularity down to milliseconds, you can set step="0.001", which is 1 millisecond
	Step float64
}

type FormFieldTime_WOP struct {
	Name string

	Value time.Time

	Step float64
}

type FormField_WOP struct {
	Name string

	InputTypeEnum InputTypeEnum

	Label string

	Placeholder string

	HasBespokeWidth bool

	BespokeWidthPx int

	HasBespokeHeight bool

	BespokeHeightPx int
}

type FormGroup struct {
	Name     string
	Label    string
	FormDivs []*FormDiv

	// If yes, a suppress button is present
	HasSuppressButton bool

	// HasSuppressButtonBeenPressed is set to true
	// when the suppress button is pressed. It is the responsability
	// of the backend to reset this value to false
	HasSuppressButtonBeenPressed bool

	// swagger:ignore
	OnSave OnSaveInterface
}

type FormGroupName string

type FormGroupOrchestrator struct {
}

type FormGroup_WOP struct {
	Name string

	Label string

	HasSuppressButton bool

	HasSuppressButtonBeenPressed bool
}

type FormSortAssocButton struct {
	Name string

	Label string

	// swagger:ignore
	OnSortEdition FormSortAssocButtonInterface

	HasToolTip  bool
	ToolTipText string

	// The link is to allows for the access to the
	// association storage
	FormEditAssocButton *FormEditAssocButton
}

type FormSortAssocButtonInterface interface {
	OnButtonPressed()
}

type FormSortAssocButtonOrchestrator struct {
}

type FormSortAssocButton_WOP struct {
	Name string

	Label string

	HasToolTip bool

	ToolTipText 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 Gong__MouseEvent struct {
	ShiftKey bool
}

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 InputTypeEnum string

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

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 OnAfterUpdateWithMouseEventInterface[Type Gongstruct] interface {
	OnAfterUpdateWithMouseEvent(stage *Stage, old, new *Type, mouseEvent *Gong__MouseEvent)
}

type OnInitCommitInterface interface {
	BeforeCommit(stage *Stage)
}

type OnSaveInterface interface {
	OnSave()
}

type Option struct {
	Name string
}

type Option_WOP struct {
	Name string
}

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 Row struct {
	Name  string
	Cells []*Cell

	IsChecked bool

	// swagger:ignore
	Impl RowImplInterface
}

type RowImplInterface interface {

	// RowUpdated function is called each time a Row is modified
	RowUpdated(stage *Stage, row, updatedRow *Row)
}

type RowOrchestrator struct {
}

type Row_WOP struct {
	Name string

	IsChecked bool
}

type Stage struct {

	// insertion point for definition of arrays registering instances
	Cells           map[*Cell]any
	Cells_mapString map[string]*Cell

	// insertion point for slice of pointers maps
	OnAfterCellCreateCallback               OnAfterCreateInterface[Cell]
	OnAfterCellUpdateCallback               OnAfterUpdateInterface[Cell]
	OnAfterCellUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[Cell]
	OnAfterCellDeleteCallback               OnAfterDeleteInterface[Cell]
	OnAfterCellReadCallback                 OnAfterReadInterface[Cell]

	CellBooleans           map[*CellBoolean]any
	CellBooleans_mapString map[string]*CellBoolean

	// insertion point for slice of pointers maps
	OnAfterCellBooleanCreateCallback               OnAfterCreateInterface[CellBoolean]
	OnAfterCellBooleanUpdateCallback               OnAfterUpdateInterface[CellBoolean]
	OnAfterCellBooleanUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[CellBoolean]
	OnAfterCellBooleanDeleteCallback               OnAfterDeleteInterface[CellBoolean]
	OnAfterCellBooleanReadCallback                 OnAfterReadInterface[CellBoolean]

	CellFloat64s           map[*CellFloat64]any
	CellFloat64s_mapString map[string]*CellFloat64

	// insertion point for slice of pointers maps
	OnAfterCellFloat64CreateCallback               OnAfterCreateInterface[CellFloat64]
	OnAfterCellFloat64UpdateCallback               OnAfterUpdateInterface[CellFloat64]
	OnAfterCellFloat64UpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[CellFloat64]
	OnAfterCellFloat64DeleteCallback               OnAfterDeleteInterface[CellFloat64]
	OnAfterCellFloat64ReadCallback                 OnAfterReadInterface[CellFloat64]

	CellIcons           map[*CellIcon]any
	CellIcons_mapString map[string]*CellIcon

	// insertion point for slice of pointers maps
	OnAfterCellIconCreateCallback               OnAfterCreateInterface[CellIcon]
	OnAfterCellIconUpdateCallback               OnAfterUpdateInterface[CellIcon]
	OnAfterCellIconUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[CellIcon]
	OnAfterCellIconDeleteCallback               OnAfterDeleteInterface[CellIcon]
	OnAfterCellIconReadCallback                 OnAfterReadInterface[CellIcon]

	CellInts           map[*CellInt]any
	CellInts_mapString map[string]*CellInt

	// insertion point for slice of pointers maps
	OnAfterCellIntCreateCallback               OnAfterCreateInterface[CellInt]
	OnAfterCellIntUpdateCallback               OnAfterUpdateInterface[CellInt]
	OnAfterCellIntUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[CellInt]
	OnAfterCellIntDeleteCallback               OnAfterDeleteInterface[CellInt]
	OnAfterCellIntReadCallback                 OnAfterReadInterface[CellInt]

	CellStrings           map[*CellString]any
	CellStrings_mapString map[string]*CellString

	// insertion point for slice of pointers maps
	OnAfterCellStringCreateCallback               OnAfterCreateInterface[CellString]
	OnAfterCellStringUpdateCallback               OnAfterUpdateInterface[CellString]
	OnAfterCellStringUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[CellString]
	OnAfterCellStringDeleteCallback               OnAfterDeleteInterface[CellString]
	OnAfterCellStringReadCallback                 OnAfterReadInterface[CellString]

	CheckBoxs           map[*CheckBox]any
	CheckBoxs_mapString map[string]*CheckBox

	// insertion point for slice of pointers maps
	OnAfterCheckBoxCreateCallback               OnAfterCreateInterface[CheckBox]
	OnAfterCheckBoxUpdateCallback               OnAfterUpdateInterface[CheckBox]
	OnAfterCheckBoxUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[CheckBox]
	OnAfterCheckBoxDeleteCallback               OnAfterDeleteInterface[CheckBox]
	OnAfterCheckBoxReadCallback                 OnAfterReadInterface[CheckBox]

	DisplayedColumns           map[*DisplayedColumn]any
	DisplayedColumns_mapString map[string]*DisplayedColumn

	// insertion point for slice of pointers maps
	OnAfterDisplayedColumnCreateCallback               OnAfterCreateInterface[DisplayedColumn]
	OnAfterDisplayedColumnUpdateCallback               OnAfterUpdateInterface[DisplayedColumn]
	OnAfterDisplayedColumnUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[DisplayedColumn]
	OnAfterDisplayedColumnDeleteCallback               OnAfterDeleteInterface[DisplayedColumn]
	OnAfterDisplayedColumnReadCallback                 OnAfterReadInterface[DisplayedColumn]

	FormDivs           map[*FormDiv]any
	FormDivs_mapString map[string]*FormDiv

	// insertion point for slice of pointers maps
	FormDiv_FormFields_reverseMap map[*FormField]*FormDiv

	FormDiv_CheckBoxs_reverseMap map[*CheckBox]*FormDiv

	OnAfterFormDivCreateCallback               OnAfterCreateInterface[FormDiv]
	OnAfterFormDivUpdateCallback               OnAfterUpdateInterface[FormDiv]
	OnAfterFormDivUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormDiv]
	OnAfterFormDivDeleteCallback               OnAfterDeleteInterface[FormDiv]
	OnAfterFormDivReadCallback                 OnAfterReadInterface[FormDiv]

	FormEditAssocButtons           map[*FormEditAssocButton]any
	FormEditAssocButtons_mapString map[string]*FormEditAssocButton

	// insertion point for slice of pointers maps
	OnAfterFormEditAssocButtonCreateCallback               OnAfterCreateInterface[FormEditAssocButton]
	OnAfterFormEditAssocButtonUpdateCallback               OnAfterUpdateInterface[FormEditAssocButton]
	OnAfterFormEditAssocButtonUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormEditAssocButton]
	OnAfterFormEditAssocButtonDeleteCallback               OnAfterDeleteInterface[FormEditAssocButton]
	OnAfterFormEditAssocButtonReadCallback                 OnAfterReadInterface[FormEditAssocButton]

	FormFields           map[*FormField]any
	FormFields_mapString map[string]*FormField

	// insertion point for slice of pointers maps
	OnAfterFormFieldCreateCallback               OnAfterCreateInterface[FormField]
	OnAfterFormFieldUpdateCallback               OnAfterUpdateInterface[FormField]
	OnAfterFormFieldUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormField]
	OnAfterFormFieldDeleteCallback               OnAfterDeleteInterface[FormField]
	OnAfterFormFieldReadCallback                 OnAfterReadInterface[FormField]

	FormFieldDates           map[*FormFieldDate]any
	FormFieldDates_mapString map[string]*FormFieldDate

	// insertion point for slice of pointers maps
	OnAfterFormFieldDateCreateCallback               OnAfterCreateInterface[FormFieldDate]
	OnAfterFormFieldDateUpdateCallback               OnAfterUpdateInterface[FormFieldDate]
	OnAfterFormFieldDateUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormFieldDate]
	OnAfterFormFieldDateDeleteCallback               OnAfterDeleteInterface[FormFieldDate]
	OnAfterFormFieldDateReadCallback                 OnAfterReadInterface[FormFieldDate]

	FormFieldDateTimes           map[*FormFieldDateTime]any
	FormFieldDateTimes_mapString map[string]*FormFieldDateTime

	// insertion point for slice of pointers maps
	OnAfterFormFieldDateTimeCreateCallback               OnAfterCreateInterface[FormFieldDateTime]
	OnAfterFormFieldDateTimeUpdateCallback               OnAfterUpdateInterface[FormFieldDateTime]
	OnAfterFormFieldDateTimeUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormFieldDateTime]
	OnAfterFormFieldDateTimeDeleteCallback               OnAfterDeleteInterface[FormFieldDateTime]
	OnAfterFormFieldDateTimeReadCallback                 OnAfterReadInterface[FormFieldDateTime]

	FormFieldFloat64s           map[*FormFieldFloat64]any
	FormFieldFloat64s_mapString map[string]*FormFieldFloat64

	// insertion point for slice of pointers maps
	OnAfterFormFieldFloat64CreateCallback               OnAfterCreateInterface[FormFieldFloat64]
	OnAfterFormFieldFloat64UpdateCallback               OnAfterUpdateInterface[FormFieldFloat64]
	OnAfterFormFieldFloat64UpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormFieldFloat64]
	OnAfterFormFieldFloat64DeleteCallback               OnAfterDeleteInterface[FormFieldFloat64]
	OnAfterFormFieldFloat64ReadCallback                 OnAfterReadInterface[FormFieldFloat64]

	FormFieldInts           map[*FormFieldInt]any
	FormFieldInts_mapString map[string]*FormFieldInt

	// insertion point for slice of pointers maps
	OnAfterFormFieldIntCreateCallback               OnAfterCreateInterface[FormFieldInt]
	OnAfterFormFieldIntUpdateCallback               OnAfterUpdateInterface[FormFieldInt]
	OnAfterFormFieldIntUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormFieldInt]
	OnAfterFormFieldIntDeleteCallback               OnAfterDeleteInterface[FormFieldInt]
	OnAfterFormFieldIntReadCallback                 OnAfterReadInterface[FormFieldInt]

	FormFieldSelects           map[*FormFieldSelect]any
	FormFieldSelects_mapString map[string]*FormFieldSelect

	// insertion point for slice of pointers maps
	FormFieldSelect_Options_reverseMap map[*Option]*FormFieldSelect

	OnAfterFormFieldSelectCreateCallback               OnAfterCreateInterface[FormFieldSelect]
	OnAfterFormFieldSelectUpdateCallback               OnAfterUpdateInterface[FormFieldSelect]
	OnAfterFormFieldSelectUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormFieldSelect]
	OnAfterFormFieldSelectDeleteCallback               OnAfterDeleteInterface[FormFieldSelect]
	OnAfterFormFieldSelectReadCallback                 OnAfterReadInterface[FormFieldSelect]

	FormFieldStrings           map[*FormFieldString]any
	FormFieldStrings_mapString map[string]*FormFieldString

	// insertion point for slice of pointers maps
	OnAfterFormFieldStringCreateCallback               OnAfterCreateInterface[FormFieldString]
	OnAfterFormFieldStringUpdateCallback               OnAfterUpdateInterface[FormFieldString]
	OnAfterFormFieldStringUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormFieldString]
	OnAfterFormFieldStringDeleteCallback               OnAfterDeleteInterface[FormFieldString]
	OnAfterFormFieldStringReadCallback                 OnAfterReadInterface[FormFieldString]

	FormFieldTimes           map[*FormFieldTime]any
	FormFieldTimes_mapString map[string]*FormFieldTime

	// insertion point for slice of pointers maps
	OnAfterFormFieldTimeCreateCallback               OnAfterCreateInterface[FormFieldTime]
	OnAfterFormFieldTimeUpdateCallback               OnAfterUpdateInterface[FormFieldTime]
	OnAfterFormFieldTimeUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormFieldTime]
	OnAfterFormFieldTimeDeleteCallback               OnAfterDeleteInterface[FormFieldTime]
	OnAfterFormFieldTimeReadCallback                 OnAfterReadInterface[FormFieldTime]

	FormGroups           map[*FormGroup]any
	FormGroups_mapString map[string]*FormGroup

	// insertion point for slice of pointers maps
	FormGroup_FormDivs_reverseMap map[*FormDiv]*FormGroup

	OnAfterFormGroupCreateCallback               OnAfterCreateInterface[FormGroup]
	OnAfterFormGroupUpdateCallback               OnAfterUpdateInterface[FormGroup]
	OnAfterFormGroupUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormGroup]
	OnAfterFormGroupDeleteCallback               OnAfterDeleteInterface[FormGroup]
	OnAfterFormGroupReadCallback                 OnAfterReadInterface[FormGroup]

	FormSortAssocButtons           map[*FormSortAssocButton]any
	FormSortAssocButtons_mapString map[string]*FormSortAssocButton

	// insertion point for slice of pointers maps
	OnAfterFormSortAssocButtonCreateCallback               OnAfterCreateInterface[FormSortAssocButton]
	OnAfterFormSortAssocButtonUpdateCallback               OnAfterUpdateInterface[FormSortAssocButton]
	OnAfterFormSortAssocButtonUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[FormSortAssocButton]
	OnAfterFormSortAssocButtonDeleteCallback               OnAfterDeleteInterface[FormSortAssocButton]
	OnAfterFormSortAssocButtonReadCallback                 OnAfterReadInterface[FormSortAssocButton]

	Options           map[*Option]any
	Options_mapString map[string]*Option

	// insertion point for slice of pointers maps
	OnAfterOptionCreateCallback               OnAfterCreateInterface[Option]
	OnAfterOptionUpdateCallback               OnAfterUpdateInterface[Option]
	OnAfterOptionUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[Option]
	OnAfterOptionDeleteCallback               OnAfterDeleteInterface[Option]
	OnAfterOptionReadCallback                 OnAfterReadInterface[Option]

	Rows           map[*Row]any
	Rows_mapString map[string]*Row

	// insertion point for slice of pointers maps
	Row_Cells_reverseMap map[*Cell]*Row

	OnAfterRowCreateCallback               OnAfterCreateInterface[Row]
	OnAfterRowUpdateCallback               OnAfterUpdateInterface[Row]
	OnAfterRowUpdateWithMouseEventCallback OnAfterUpdateWithMouseEventInterface[Row]
	OnAfterRowDeleteCallback               OnAfterDeleteInterface[Row]
	OnAfterRowReadCallback                 OnAfterReadInterface[Row]

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

	// insertion point for slice of pointers maps
	Table_DisplayedColumns_reverseMap map[*DisplayedColumn]*Table

	Table_Rows_reverseMap map[*Row]*Table

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

	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
	CellOrder            uint
	CellMap_Staged_Order map[*Cell]uint

	CellBooleanOrder            uint
	CellBooleanMap_Staged_Order map[*CellBoolean]uint

	CellFloat64Order            uint
	CellFloat64Map_Staged_Order map[*CellFloat64]uint

	CellIconOrder            uint
	CellIconMap_Staged_Order map[*CellIcon]uint

	CellIntOrder            uint
	CellIntMap_Staged_Order map[*CellInt]uint

	CellStringOrder            uint
	CellStringMap_Staged_Order map[*CellString]uint

	CheckBoxOrder            uint
	CheckBoxMap_Staged_Order map[*CheckBox]uint

	DisplayedColumnOrder            uint
	DisplayedColumnMap_Staged_Order map[*DisplayedColumn]uint

	FormDivOrder            uint
	FormDivMap_Staged_Order map[*FormDiv]uint

	FormEditAssocButtonOrder            uint
	FormEditAssocButtonMap_Staged_Order map[*FormEditAssocButton]uint

	FormFieldOrder            uint
	FormFieldMap_Staged_Order map[*FormField]uint

	FormFieldDateOrder            uint
	FormFieldDateMap_Staged_Order map[*FormFieldDate]uint

	FormFieldDateTimeOrder            uint
	FormFieldDateTimeMap_Staged_Order map[*FormFieldDateTime]uint

	FormFieldFloat64Order            uint
	FormFieldFloat64Map_Staged_Order map[*FormFieldFloat64]uint

	FormFieldIntOrder            uint
	FormFieldIntMap_Staged_Order map[*FormFieldInt]uint

	FormFieldSelectOrder            uint
	FormFieldSelectMap_Staged_Order map[*FormFieldSelect]uint

	FormFieldStringOrder            uint
	FormFieldStringMap_Staged_Order map[*FormFieldString]uint

	FormFieldTimeOrder            uint
	FormFieldTimeMap_Staged_Order map[*FormFieldTime]uint

	FormGroupOrder            uint
	FormGroupMap_Staged_Order map[*FormGroup]uint

	FormSortAssocButtonOrder            uint
	FormSortAssocButtonMap_Staged_Order map[*FormSortAssocButton]uint

	OptionOrder            uint
	OptionMap_Staged_Order map[*Option]uint

	RowOrder            uint
	RowMap_Staged_Order map[*Row]uint

	TableOrder            uint
	TableMap_Staged_Order map[*Table]uint

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

type Table struct {
	Name             string
	DisplayedColumns []*DisplayedColumn
	Rows             []*Row

	HasFiltering     bool
	HasColumnSorting bool
	HasPaginator     bool

	HasCheckableRows bool

	HasSaveButton   bool
	SaveButtonLabel string

	CanDragDropRows bool
	HasCloseButton  bool // Is used in case of drag drop since drag drop operation save the result

	// SavingInProgress is true when rows are being saved
	// it is set to true by the front at the begining and set back
	// to false by the front
	// This information is used by the back to compute when all rows to be updated
	// have been updated
	SavingInProgress bool

	// The `sticky` property in CSS positions an element based on user's scroll,
	// allowing it to be fixed within its parent after a scroll point is reached.
	// NbOfStickyColumns defines the number of sticky column at the left of the table
	NbOfStickyColumns int

	// swagger:ignore
	Impl TableImplInterface
}

type TableExtraNameEnum string

type TableExtraPathEnum string

type TableImplInterface interface {

	// TableUpdated function is called each time a Table is modified
	TableUpdated(stage *Stage, table, updatedTable *Table)
}

type TableName string