models

type All struct {
	Name string
	Annotated

	ModelGroup
}

type AllModelsStructCreateInterface interface {
	CreateORMAll(All *All)
	CreateORMAnnotation(Annotation *Annotation)
	CreateORMAttribute(Attribute *Attribute)
	CreateORMAttributeGroup(AttributeGroup *AttributeGroup)
	CreateORMChoice(Choice *Choice)
	CreateORMComplexContent(ComplexContent *ComplexContent)
	CreateORMComplexType(ComplexType *ComplexType)
	CreateORMDocumentation(Documentation *Documentation)
	CreateORMElement(Element *Element)
	CreateORMEnumeration(Enumeration *Enumeration)
	CreateORMExtension(Extension *Extension)
	CreateORMGroup(Group *Group)
	CreateORMLength(Length *Length)
	CreateORMMaxInclusive(MaxInclusive *MaxInclusive)
	CreateORMMaxLength(MaxLength *MaxLength)
	CreateORMMinInclusive(MinInclusive *MinInclusive)
	CreateORMMinLength(MinLength *MinLength)
	CreateORMPattern(Pattern *Pattern)
	CreateORMRestriction(Restriction *Restriction)
	CreateORMSchema(Schema *Schema)
	CreateORMSequence(Sequence *Sequence)
	CreateORMSimpleContent(SimpleContent *SimpleContent)
	CreateORMSimpleType(SimpleType *SimpleType)
	CreateORMTotalDigit(TotalDigit *TotalDigit)
	CreateORMUnion(Union *Union)
	CreateORMWhiteSpace(WhiteSpace *WhiteSpace)
}

type AllModelsStructDeleteInterface interface {
	DeleteORMAll(All *All)
	DeleteORMAnnotation(Annotation *Annotation)
	DeleteORMAttribute(Attribute *Attribute)
	DeleteORMAttributeGroup(AttributeGroup *AttributeGroup)
	DeleteORMChoice(Choice *Choice)
	DeleteORMComplexContent(ComplexContent *ComplexContent)
	DeleteORMComplexType(ComplexType *ComplexType)
	DeleteORMDocumentation(Documentation *Documentation)
	DeleteORMElement(Element *Element)
	DeleteORMEnumeration(Enumeration *Enumeration)
	DeleteORMExtension(Extension *Extension)
	DeleteORMGroup(Group *Group)
	DeleteORMLength(Length *Length)
	DeleteORMMaxInclusive(MaxInclusive *MaxInclusive)
	DeleteORMMaxLength(MaxLength *MaxLength)
	DeleteORMMinInclusive(MinInclusive *MinInclusive)
	DeleteORMMinLength(MinLength *MinLength)
	DeleteORMPattern(Pattern *Pattern)
	DeleteORMRestriction(Restriction *Restriction)
	DeleteORMSchema(Schema *Schema)
	DeleteORMSequence(Sequence *Sequence)
	DeleteORMSimpleContent(SimpleContent *SimpleContent)
	DeleteORMSimpleType(SimpleType *SimpleType)
	DeleteORMTotalDigit(TotalDigit *TotalDigit)
	DeleteORMUnion(Union *Union)
	DeleteORMWhiteSpace(WhiteSpace *WhiteSpace)
}

type All_WOP struct {
	// insertion point
	Name             string
	OuterElementName string
	Order            int
	Depth            int
	MinOccurs        string
	MaxOccurs        string
}

type Annotated struct {
	Annotation *Annotation `xml:"annotation"`
}

type Annotation struct {
	Name           string
	Documentations []*Documentation `xml:"documentation"`
}

type Annotation_WOP struct {
	// insertion point
	Name string
}

type Attribute struct {
	Name string
	ElementWithNameAttribute
	ElementWithTypeAttribute
	Annotated

	WithGoIdentifier

	Default         string `xml:"default,attr"`
	Use             string `xml:"use,attr"`
	Form            string `xml:"form,attr"`
	Fixed           string `xml:"fixed,attr"`
	Ref             string `xml:"ref,attr"`
	TargetNamespace string `xml:"targetNamespace,attr"`
	SimpleType      string `xml:"simpleType,attr"`
	IDXSD           string `xml:"id,attr"`
}

type AttributeGroup struct {
	Name string
	ElementWithNameAttribute
	Annotated
	WithGoIdentifier

	AttributeGroups []*AttributeGroup `xml:"attributeGroup"`

	Ref string `xml:"ref,attr"`

	Attributes []*Attribute `xml:"attribute"`

	ParticleAbstract
}

type AttributeGroup_WOP struct {
	// insertion point
	Name            string
	NameXSD         string
	HasNameConflict bool
	GoIdentifier    string
	Ref             string
	Order           int
	Depth           int
}

type Attribute_WOP struct {
	// insertion point
	Name            string
	NameXSD         string
	Type            string
	HasNameConflict bool
	GoIdentifier    string
	Default         string
	Use             string
	Form            string
	Fixed           string
	Ref             string
	TargetNamespace string
	SimpleType      string
	IDXSD           string
}

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
	CommitAll(all *All)
	CheckoutAll(all *All)
	CommitAnnotation(annotation *Annotation)
	CheckoutAnnotation(annotation *Annotation)
	CommitAttribute(attribute *Attribute)
	CheckoutAttribute(attribute *Attribute)
	CommitAttributeGroup(attributegroup *AttributeGroup)
	CheckoutAttributeGroup(attributegroup *AttributeGroup)
	CommitChoice(choice *Choice)
	CheckoutChoice(choice *Choice)
	CommitComplexContent(complexcontent *ComplexContent)
	CheckoutComplexContent(complexcontent *ComplexContent)
	CommitComplexType(complextype *ComplexType)
	CheckoutComplexType(complextype *ComplexType)
	CommitDocumentation(documentation *Documentation)
	CheckoutDocumentation(documentation *Documentation)
	CommitElement(element *Element)
	CheckoutElement(element *Element)
	CommitEnumeration(enumeration *Enumeration)
	CheckoutEnumeration(enumeration *Enumeration)
	CommitExtension(extension *Extension)
	CheckoutExtension(extension *Extension)
	CommitGroup(group *Group)
	CheckoutGroup(group *Group)
	CommitLength(length *Length)
	CheckoutLength(length *Length)
	CommitMaxInclusive(maxinclusive *MaxInclusive)
	CheckoutMaxInclusive(maxinclusive *MaxInclusive)
	CommitMaxLength(maxlength *MaxLength)
	CheckoutMaxLength(maxlength *MaxLength)
	CommitMinInclusive(mininclusive *MinInclusive)
	CheckoutMinInclusive(mininclusive *MinInclusive)
	CommitMinLength(minlength *MinLength)
	CheckoutMinLength(minlength *MinLength)
	CommitPattern(pattern *Pattern)
	CheckoutPattern(pattern *Pattern)
	CommitRestriction(restriction *Restriction)
	CheckoutRestriction(restriction *Restriction)
	CommitSchema(schema *Schema)
	CheckoutSchema(schema *Schema)
	CommitSequence(sequence *Sequence)
	CheckoutSequence(sequence *Sequence)
	CommitSimpleContent(simplecontent *SimpleContent)
	CheckoutSimpleContent(simplecontent *SimpleContent)
	CommitSimpleType(simpletype *SimpleType)
	CheckoutSimpleType(simpletype *SimpleType)
	CommitTotalDigit(totaldigit *TotalDigit)
	CheckoutTotalDigit(totaldigit *TotalDigit)
	CommitUnion(union *Union)
	CheckoutUnion(union *Union)
	CommitWhiteSpace(whitespace *WhiteSpace)
	CheckoutWhiteSpace(whitespace *WhiteSpace)
	GetLastCommitFromBackNb() uint
	GetLastPushFromFrontNb() uint
}

type Choice struct {
	Name string
	Annotated

	ModelGroup

	IsDuplicatedInXSD bool

	OuterParticle Particle
}

type Choice_WOP struct {
	// insertion point
	Name              string
	OuterElementName  string
	Order             int
	Depth             int
	MinOccurs         string
	MaxOccurs         string
	IsDuplicatedInXSD bool
}

type ComplexContent struct {
	Name string
}

type ComplexContent_WOP struct {
	// insertion point
	Name string
}

type ComplexType struct {
	Name string

	WithGoIdentifier

	// analysis
	IsAnonymous  bool
	OuterElement *Element // if anonymous

	Annotated
	ElementWithNameAttribute

	ModelGroup

	Extension *Extension `xml:"extension"`

	// xs:simpleContent element is used exclusively within an xs:complexType element
	// to define complex types that contain simple content along with
	// attributes or restrictions.
	SimpleContent *SimpleContent `xml:"simpleContent"`

	ComplexContent *ComplexContent `xml:"complexContent"`

	Attributes      []*Attribute      `xml:"attribute"`
	AttributeGroups []*AttributeGroup `xml:"attributeGroup"`

	IsDuplicatedInXSD bool

	OuterParticleOwnerAbstract
}

type ComplexType_WOP struct {
	// insertion point
	Name              string
	HasNameConflict   bool
	GoIdentifier      string
	IsAnonymous       bool
	NameXSD           string
	OuterElementName  string
	Order             int
	Depth             int
	MinOccurs         string
	MaxOccurs         string
	IsDuplicatedInXSD bool
}

type Documentation struct {
	Name   string
	Text   string `xml:",chardata"`
	Source string `xml:"source,attr"`
	Lang   string `xml:"lang,attr"`
}

type Documentation_WOP struct {
	// insertion point
	Name   string
	Text   string
	Source string
	Lang   string
}

type Element struct {
	Name string

	ParticleAbstract

	// analysis
	WithGoIdentifier

	Annotated
	ElementWithNameAttribute
	ElementWithTypeAttribute

	OccurrenceDefinitionAbstract

	Default  string `xml:"default,attr"`
	Fixed    string `xml:"fixed,attr"`
	Nillable string `xml:"nillable,attr"`
	Ref      string `xml:"ref,attr"`
	Abstract string `xml:"abstract,attr"`
	Form     string `xml:"form,attr"`
	Block    string `xml:"block,attr"`
	Final    string `xml:"final,attr"`

	SimpleType  *SimpleType  `xml:"simpleType"`
	ComplexType *ComplexType `xml:"complexType"`
	Groups      []*Group     `xml:"group"`

	OuterParticleOwnerAbstract

	IsDuplicatedInXSD bool
}

type ElementWithNameAttribute struct {
	NameXSD string `xml:"name,attr"`
}

type ElementWithTypeAttribute struct {
	Type string `xml:"type,attr"`
}

type ElementWithValueAttribute struct {
	Value string `xml:"value,attr"`
}

type Element_WOP struct {
	// insertion point
	Name              string
	Order             int
	Depth             int
	HasNameConflict   bool
	GoIdentifier      string
	NameXSD           string
	Type              string
	MinOccurs         string
	MaxOccurs         string
	Default           string
	Fixed             string
	Nillable          string
	Ref               string
	Abstract          string
	Form              string
	Block             string
	Final             string
	IsDuplicatedInXSD bool
}

type Enumeration struct {
	Name string
	Annotated
	ElementWithValueAttribute
}

type Enumeration_WOP struct {
	// insertion point
	Name  string
	Value string
}

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

type Extension struct {
	Name string
	ModelGroup

	Base string `xml:"base,attr"`
	Ref  string `xml:"ref,attr"`

	Attributes      []*Attribute      `xml:"attribute"`
	AttributeGroups []*AttributeGroup `xml:"attributeGroup"`
}

type Extension_WOP struct {
	// insertion point
	Name             string
	OuterElementName string
	Order            int
	Depth            int
	MinOccurs        string
	MaxOccurs        string
	Base             string
	Ref              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 | Level0 | Level1 | Level2 | Level3
	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 Group struct {
	Name string
	Annotated
	ElementWithNameAttribute
	Ref string `xml:"ref,attr"`

	// analysis
	IsAnonymous  bool // it has been defined by the enclosing element
	OuterElement *Element
	WithGoIdentifier

	ModelGroup
}

type Group_WOP struct {
	// insertion point
	Name             string
	NameXSD          string
	Ref              string
	IsAnonymous      bool
	HasNameConflict  bool
	GoIdentifier     string
	OuterElementName string
	Order            int
	Depth            int
	MinOccurs        string
	MaxOccurs        string
}

type Length struct {
	Name string
	Annotated
	ElementWithValueAttribute
}

type Length_WOP struct {
	// insertion point
	Name  string
	Value string
}

type Level0 int

type Level1 int

type Level2 int

type Level3 int

type MaxInclusive struct {
	Name string
	Annotated
	ElementWithValueAttribute
}

type MaxInclusive_WOP struct {
	// insertion point
	Name  string
	Value string
}

type MaxLength struct {
	Name string
	Annotated
	ElementWithValueAttribute
}

type MaxLength_WOP struct {
	// insertion point
	Name  string
	Value string
}

type MinInclusive struct {
	Name string
	Annotated
	ElementWithValueAttribute
}

type MinInclusive_WOP struct {
	// insertion point
	Name  string
	Value string
}

type MinLength struct {
	Name string
	Annotated
	ElementWithValueAttribute
}

type MinLength_WOP struct {
	// insertion point
	Name  string
	Value string
}

type ModelGroup struct {
	OuterElementName string

	Sequences []*Sequence `xml:"sequence"`
	Alls      []*All      `xml:"all"`
	Choices   []*Choice   `xml:"choice"`
	Groups    []*Group    `xml:"group"`

	Elements []*Element `xml:"element"`

	ParticleAbstract
	OccurrenceDefinitionAbstract
}

type OccurrenceDefinition interface {
	GetIsLocalyUnbounded() bool
}

type OccurrenceDefinitionAbstract struct {
	MinOccurs string `xml:"minOccurs,attr"`
	MaxOccurs string `xml:"maxOccurs,attr"`
}

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 OuterParticleOwner interface {
	GetOuterParticle() Particle
	SetOuterParticle(particle Particle)
}

type OuterParticleOwnerAbstract struct {
	// OuterParticle is the particle that reference the element
	// this is used in the factoring process of non normalized xsd
	OuterParticle Particle `xml:"-"`
}

type Particle interface {
	GetOrder() int
	GetParent() Particle
	SetParentAndChildren(Particle) //
}

type ParticleAbstract struct {
	// Order is the order at wich the particle was unmarshalled in the xsd
	// It is important to preserve the order output that is defined in the xsd
	Order int `xml:"-"`
	Depth int `xml:"-"`

	Parent   Particle
	Children []Particle
}

type Pattern struct {
	Name string
	Annotated
	ElementWithValueAttribute
}

type Pattern_WOP struct {
	// insertion point
	Name  string
	Value string
}

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

type PointerToGongstructEnumIntField interface {
	*Level0 | *Level1 | *Level2 | *Level3
	FromCodeString(input string) (err error)
}

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

type Restriction struct {
	Name string
	Annotated

	Base string `xml:"base,attr"`

	Enumerations []*Enumeration `xml:"enumeration"`
	MinInclusive *MinInclusive  `xml:"minInclusive"`
	MaxInclusive *MaxInclusive  `xml:"maxInclusive"`
	Pattern      *Pattern       `xml:"pattern"`
	WhiteSpace   *WhiteSpace    `xml:"whiteSpace"`
	MinLength    *MinLength     `xml:"minLength"`
	MaxLength    *MaxLength     `xml:"maxLength"`
	Length       *Length        `xml:"length"`
	TotalDigit   *TotalDigit    `xml:"totalDigits"`
}

type Restriction_WOP struct {
	// insertion point
	Name string
	Base string
}

type ReverseField struct {
	GongstructName string
	Fieldname      string
}

type Schema struct {
	Name string
	Xs   string `xml:"xs,attr"`

	// Xmlns represents namespaces like xmlns:xsd="http://www.w3.org/2001/XMLSchema"
	// they are unmarshall via a custom unmarshaller
	Xmlns Xmlns `xml:"-"`

	Annotated
	Elements        []*Element        `xml:"element"`
	SimpleTypes     []*SimpleType     `xml:"simpleType"`
	ComplexTypes    []*ComplexType    `xml:"complexType"`
	AttributeGroups []*AttributeGroup `xml:"attributeGroup"`
	Groups          []*Group          `xml:"group"`

	ParticleAbstract
}

type Schema_WOP struct {
	// insertion point
	Name  string
	Xs    string
	Order int
	Depth int
}

type Sequence struct {
	Name string
	Annotated

	ModelGroup

	OuterParticleOwnerAbstract
}

type Sequence_WOP struct {
	// insertion point
	Name             string
	OuterElementName string
	Order            int
	Depth            int
	MinOccurs        string
	MaxOccurs        string
}

type SimpleContent struct {
	Name string

	Extension   *Extension   `xml:"extension"`
	Restriction *Restriction `xml:"restriction"`
}

type SimpleContent_WOP struct {
	// insertion point
	Name string
}

type SimpleType struct {
	Name string
	Annotated
	ElementWithNameAttribute
	Restriction *Restriction `xml:"restriction"`
	Union       *Union       `xml:"union"`

	ParticleAbstract
}

type SimpleType_WOP struct {
	// insertion point
	Name    string
	NameXSD string
	Order   int
	Depth   int
}

type StageStruct struct {

	// insertion point for definition of arrays registering instances
	Alls           map[*All]any
	Alls_mapString map[string]*All

	// insertion point for slice of pointers maps
	All_Sequences_reverseMap map[*Sequence]*All

	All_Alls_reverseMap map[*All]*All

	All_Choices_reverseMap map[*Choice]*All

	All_Groups_reverseMap map[*Group]*All

	All_Elements_reverseMap map[*Element]*All

	OnAfterAllCreateCallback OnAfterCreateInterface[All]
	OnAfterAllUpdateCallback OnAfterUpdateInterface[All]
	OnAfterAllDeleteCallback OnAfterDeleteInterface[All]
	OnAfterAllReadCallback   OnAfterReadInterface[All]

	Annotations           map[*Annotation]any
	Annotations_mapString map[string]*Annotation

	// insertion point for slice of pointers maps
	Annotation_Documentations_reverseMap map[*Documentation]*Annotation

	OnAfterAnnotationCreateCallback OnAfterCreateInterface[Annotation]
	OnAfterAnnotationUpdateCallback OnAfterUpdateInterface[Annotation]
	OnAfterAnnotationDeleteCallback OnAfterDeleteInterface[Annotation]
	OnAfterAnnotationReadCallback   OnAfterReadInterface[Annotation]

	Attributes           map[*Attribute]any
	Attributes_mapString map[string]*Attribute

	// insertion point for slice of pointers maps
	OnAfterAttributeCreateCallback OnAfterCreateInterface[Attribute]
	OnAfterAttributeUpdateCallback OnAfterUpdateInterface[Attribute]
	OnAfterAttributeDeleteCallback OnAfterDeleteInterface[Attribute]
	OnAfterAttributeReadCallback   OnAfterReadInterface[Attribute]

	AttributeGroups           map[*AttributeGroup]any
	AttributeGroups_mapString map[string]*AttributeGroup

	// insertion point for slice of pointers maps
	AttributeGroup_AttributeGroups_reverseMap map[*AttributeGroup]*AttributeGroup

	AttributeGroup_Attributes_reverseMap map[*Attribute]*AttributeGroup

	OnAfterAttributeGroupCreateCallback OnAfterCreateInterface[AttributeGroup]
	OnAfterAttributeGroupUpdateCallback OnAfterUpdateInterface[AttributeGroup]
	OnAfterAttributeGroupDeleteCallback OnAfterDeleteInterface[AttributeGroup]
	OnAfterAttributeGroupReadCallback   OnAfterReadInterface[AttributeGroup]

	Choices           map[*Choice]any
	Choices_mapString map[string]*Choice

	// insertion point for slice of pointers maps
	Choice_Sequences_reverseMap map[*Sequence]*Choice

	Choice_Alls_reverseMap map[*All]*Choice

	Choice_Choices_reverseMap map[*Choice]*Choice

	Choice_Groups_reverseMap map[*Group]*Choice

	Choice_Elements_reverseMap map[*Element]*Choice

	OnAfterChoiceCreateCallback OnAfterCreateInterface[Choice]
	OnAfterChoiceUpdateCallback OnAfterUpdateInterface[Choice]
	OnAfterChoiceDeleteCallback OnAfterDeleteInterface[Choice]
	OnAfterChoiceReadCallback   OnAfterReadInterface[Choice]

	ComplexContents           map[*ComplexContent]any
	ComplexContents_mapString map[string]*ComplexContent

	// insertion point for slice of pointers maps
	OnAfterComplexContentCreateCallback OnAfterCreateInterface[ComplexContent]
	OnAfterComplexContentUpdateCallback OnAfterUpdateInterface[ComplexContent]
	OnAfterComplexContentDeleteCallback OnAfterDeleteInterface[ComplexContent]
	OnAfterComplexContentReadCallback   OnAfterReadInterface[ComplexContent]

	ComplexTypes           map[*ComplexType]any
	ComplexTypes_mapString map[string]*ComplexType

	// insertion point for slice of pointers maps
	ComplexType_Sequences_reverseMap map[*Sequence]*ComplexType

	ComplexType_Alls_reverseMap map[*All]*ComplexType

	ComplexType_Choices_reverseMap map[*Choice]*ComplexType

	ComplexType_Groups_reverseMap map[*Group]*ComplexType

	ComplexType_Elements_reverseMap map[*Element]*ComplexType

	ComplexType_Attributes_reverseMap map[*Attribute]*ComplexType

	ComplexType_AttributeGroups_reverseMap map[*AttributeGroup]*ComplexType

	OnAfterComplexTypeCreateCallback OnAfterCreateInterface[ComplexType]
	OnAfterComplexTypeUpdateCallback OnAfterUpdateInterface[ComplexType]
	OnAfterComplexTypeDeleteCallback OnAfterDeleteInterface[ComplexType]
	OnAfterComplexTypeReadCallback   OnAfterReadInterface[ComplexType]

	Documentations           map[*Documentation]any
	Documentations_mapString map[string]*Documentation

	// insertion point for slice of pointers maps
	OnAfterDocumentationCreateCallback OnAfterCreateInterface[Documentation]
	OnAfterDocumentationUpdateCallback OnAfterUpdateInterface[Documentation]
	OnAfterDocumentationDeleteCallback OnAfterDeleteInterface[Documentation]
	OnAfterDocumentationReadCallback   OnAfterReadInterface[Documentation]

	Elements           map[*Element]any
	Elements_mapString map[string]*Element

	// insertion point for slice of pointers maps
	Element_Groups_reverseMap map[*Group]*Element

	OnAfterElementCreateCallback OnAfterCreateInterface[Element]
	OnAfterElementUpdateCallback OnAfterUpdateInterface[Element]
	OnAfterElementDeleteCallback OnAfterDeleteInterface[Element]
	OnAfterElementReadCallback   OnAfterReadInterface[Element]

	Enumerations           map[*Enumeration]any
	Enumerations_mapString map[string]*Enumeration

	// insertion point for slice of pointers maps
	OnAfterEnumerationCreateCallback OnAfterCreateInterface[Enumeration]
	OnAfterEnumerationUpdateCallback OnAfterUpdateInterface[Enumeration]
	OnAfterEnumerationDeleteCallback OnAfterDeleteInterface[Enumeration]
	OnAfterEnumerationReadCallback   OnAfterReadInterface[Enumeration]

	Extensions           map[*Extension]any
	Extensions_mapString map[string]*Extension

	// insertion point for slice of pointers maps
	Extension_Sequences_reverseMap map[*Sequence]*Extension

	Extension_Alls_reverseMap map[*All]*Extension

	Extension_Choices_reverseMap map[*Choice]*Extension

	Extension_Groups_reverseMap map[*Group]*Extension

	Extension_Elements_reverseMap map[*Element]*Extension

	Extension_Attributes_reverseMap map[*Attribute]*Extension

	Extension_AttributeGroups_reverseMap map[*AttributeGroup]*Extension

	OnAfterExtensionCreateCallback OnAfterCreateInterface[Extension]
	OnAfterExtensionUpdateCallback OnAfterUpdateInterface[Extension]
	OnAfterExtensionDeleteCallback OnAfterDeleteInterface[Extension]
	OnAfterExtensionReadCallback   OnAfterReadInterface[Extension]

	Groups           map[*Group]any
	Groups_mapString map[string]*Group

	// insertion point for slice of pointers maps
	Group_Sequences_reverseMap map[*Sequence]*Group

	Group_Alls_reverseMap map[*All]*Group

	Group_Choices_reverseMap map[*Choice]*Group

	Group_Groups_reverseMap map[*Group]*Group

	Group_Elements_reverseMap map[*Element]*Group

	OnAfterGroupCreateCallback OnAfterCreateInterface[Group]
	OnAfterGroupUpdateCallback OnAfterUpdateInterface[Group]
	OnAfterGroupDeleteCallback OnAfterDeleteInterface[Group]
	OnAfterGroupReadCallback   OnAfterReadInterface[Group]

	Lengths           map[*Length]any
	Lengths_mapString map[string]*Length

	// insertion point for slice of pointers maps
	OnAfterLengthCreateCallback OnAfterCreateInterface[Length]
	OnAfterLengthUpdateCallback OnAfterUpdateInterface[Length]
	OnAfterLengthDeleteCallback OnAfterDeleteInterface[Length]
	OnAfterLengthReadCallback   OnAfterReadInterface[Length]

	MaxInclusives           map[*MaxInclusive]any
	MaxInclusives_mapString map[string]*MaxInclusive

	// insertion point for slice of pointers maps
	OnAfterMaxInclusiveCreateCallback OnAfterCreateInterface[MaxInclusive]
	OnAfterMaxInclusiveUpdateCallback OnAfterUpdateInterface[MaxInclusive]
	OnAfterMaxInclusiveDeleteCallback OnAfterDeleteInterface[MaxInclusive]
	OnAfterMaxInclusiveReadCallback   OnAfterReadInterface[MaxInclusive]

	MaxLengths           map[*MaxLength]any
	MaxLengths_mapString map[string]*MaxLength

	// insertion point for slice of pointers maps
	OnAfterMaxLengthCreateCallback OnAfterCreateInterface[MaxLength]
	OnAfterMaxLengthUpdateCallback OnAfterUpdateInterface[MaxLength]
	OnAfterMaxLengthDeleteCallback OnAfterDeleteInterface[MaxLength]
	OnAfterMaxLengthReadCallback   OnAfterReadInterface[MaxLength]

	MinInclusives           map[*MinInclusive]any
	MinInclusives_mapString map[string]*MinInclusive

	// insertion point for slice of pointers maps
	OnAfterMinInclusiveCreateCallback OnAfterCreateInterface[MinInclusive]
	OnAfterMinInclusiveUpdateCallback OnAfterUpdateInterface[MinInclusive]
	OnAfterMinInclusiveDeleteCallback OnAfterDeleteInterface[MinInclusive]
	OnAfterMinInclusiveReadCallback   OnAfterReadInterface[MinInclusive]

	MinLengths           map[*MinLength]any
	MinLengths_mapString map[string]*MinLength

	// insertion point for slice of pointers maps
	OnAfterMinLengthCreateCallback OnAfterCreateInterface[MinLength]
	OnAfterMinLengthUpdateCallback OnAfterUpdateInterface[MinLength]
	OnAfterMinLengthDeleteCallback OnAfterDeleteInterface[MinLength]
	OnAfterMinLengthReadCallback   OnAfterReadInterface[MinLength]

	Patterns           map[*Pattern]any
	Patterns_mapString map[string]*Pattern

	// insertion point for slice of pointers maps
	OnAfterPatternCreateCallback OnAfterCreateInterface[Pattern]
	OnAfterPatternUpdateCallback OnAfterUpdateInterface[Pattern]
	OnAfterPatternDeleteCallback OnAfterDeleteInterface[Pattern]
	OnAfterPatternReadCallback   OnAfterReadInterface[Pattern]

	Restrictions           map[*Restriction]any
	Restrictions_mapString map[string]*Restriction

	// insertion point for slice of pointers maps
	Restriction_Enumerations_reverseMap map[*Enumeration]*Restriction

	OnAfterRestrictionCreateCallback OnAfterCreateInterface[Restriction]
	OnAfterRestrictionUpdateCallback OnAfterUpdateInterface[Restriction]
	OnAfterRestrictionDeleteCallback OnAfterDeleteInterface[Restriction]
	OnAfterRestrictionReadCallback   OnAfterReadInterface[Restriction]

	Schemas           map[*Schema]any
	Schemas_mapString map[string]*Schema

	// insertion point for slice of pointers maps
	Schema_Elements_reverseMap map[*Element]*Schema

	Schema_SimpleTypes_reverseMap map[*SimpleType]*Schema

	Schema_ComplexTypes_reverseMap map[*ComplexType]*Schema

	Schema_AttributeGroups_reverseMap map[*AttributeGroup]*Schema

	Schema_Groups_reverseMap map[*Group]*Schema

	OnAfterSchemaCreateCallback OnAfterCreateInterface[Schema]
	OnAfterSchemaUpdateCallback OnAfterUpdateInterface[Schema]
	OnAfterSchemaDeleteCallback OnAfterDeleteInterface[Schema]
	OnAfterSchemaReadCallback   OnAfterReadInterface[Schema]

	Sequences           map[*Sequence]any
	Sequences_mapString map[string]*Sequence

	// insertion point for slice of pointers maps
	Sequence_Sequences_reverseMap map[*Sequence]*Sequence

	Sequence_Alls_reverseMap map[*All]*Sequence

	Sequence_Choices_reverseMap map[*Choice]*Sequence

	Sequence_Groups_reverseMap map[*Group]*Sequence

	Sequence_Elements_reverseMap map[*Element]*Sequence

	OnAfterSequenceCreateCallback OnAfterCreateInterface[Sequence]
	OnAfterSequenceUpdateCallback OnAfterUpdateInterface[Sequence]
	OnAfterSequenceDeleteCallback OnAfterDeleteInterface[Sequence]
	OnAfterSequenceReadCallback   OnAfterReadInterface[Sequence]

	SimpleContents           map[*SimpleContent]any
	SimpleContents_mapString map[string]*SimpleContent

	// insertion point for slice of pointers maps
	OnAfterSimpleContentCreateCallback OnAfterCreateInterface[SimpleContent]
	OnAfterSimpleContentUpdateCallback OnAfterUpdateInterface[SimpleContent]
	OnAfterSimpleContentDeleteCallback OnAfterDeleteInterface[SimpleContent]
	OnAfterSimpleContentReadCallback   OnAfterReadInterface[SimpleContent]

	SimpleTypes           map[*SimpleType]any
	SimpleTypes_mapString map[string]*SimpleType

	// insertion point for slice of pointers maps
	OnAfterSimpleTypeCreateCallback OnAfterCreateInterface[SimpleType]
	OnAfterSimpleTypeUpdateCallback OnAfterUpdateInterface[SimpleType]
	OnAfterSimpleTypeDeleteCallback OnAfterDeleteInterface[SimpleType]
	OnAfterSimpleTypeReadCallback   OnAfterReadInterface[SimpleType]

	TotalDigits           map[*TotalDigit]any
	TotalDigits_mapString map[string]*TotalDigit

	// insertion point for slice of pointers maps
	OnAfterTotalDigitCreateCallback OnAfterCreateInterface[TotalDigit]
	OnAfterTotalDigitUpdateCallback OnAfterUpdateInterface[TotalDigit]
	OnAfterTotalDigitDeleteCallback OnAfterDeleteInterface[TotalDigit]
	OnAfterTotalDigitReadCallback   OnAfterReadInterface[TotalDigit]

	Unions           map[*Union]any
	Unions_mapString map[string]*Union

	// insertion point for slice of pointers maps
	OnAfterUnionCreateCallback OnAfterCreateInterface[Union]
	OnAfterUnionUpdateCallback OnAfterUpdateInterface[Union]
	OnAfterUnionDeleteCallback OnAfterDeleteInterface[Union]
	OnAfterUnionReadCallback   OnAfterReadInterface[Union]

	WhiteSpaces           map[*WhiteSpace]any
	WhiteSpaces_mapString map[string]*WhiteSpace

	// insertion point for slice of pointers maps
	OnAfterWhiteSpaceCreateCallback OnAfterCreateInterface[WhiteSpace]
	OnAfterWhiteSpaceUpdateCallback OnAfterUpdateInterface[WhiteSpace]
	OnAfterWhiteSpaceDeleteCallback OnAfterDeleteInterface[WhiteSpace]
	OnAfterWhiteSpaceReadCallback   OnAfterReadInterface[WhiteSpace]

	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
}