model

type AnnulmentEvent struct {
	GeneralEvent
	GeneralUnionEvent
}

type Anomaly struct {
	Category AnomalyCategory
	Text     string
	Context  string
}

type AnomalyCategory string

type ApprenticeEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type ArrivalEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type Association struct {
	Kind      AssociationKind
	Other     *Person
	Citations []*GeneralCitation
}

type AssociationKind string

type BaptismEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type BattleEvent struct {
	GeneralEvent
	GeneralMultipartyEvent
}

type BirthEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type BuildingKind string

type BurialEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type CensusEntry struct {
	Principal      *Person
	RelationToHead CensusEntryRelation // cleaned
	Name           string              // as recorded
	Sex            string              // as recorded
	MaritalStatus  CensusEntryMaritalStatus
	Age            string // as recorded
	Occupation     string // as recorded
	PlaceOfBirth   string // as recorded
	Impairment     string // as recorded (deaf and dumb, blind, imbecile etc)
	Detail         string // any remaining unparsed detail
	Narrative      string // hand written narrative, if any
}

type CensusEntryMaritalStatus string

type CensusEntryRelation string

type CensusEvent struct {
	GeneralEvent
	Entries []*CensusEntry
}

type CitationMatcher func(*GeneralCitation) bool

type CitedMediaObject struct {
	Object    *MediaObject
	Highlight *Region
}

type CremationEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type Crop struct {
	Left   int
	Top    int
	Width  int
	Height int
}

type Date struct {
	Date       gdate.Date
	Derivation DateDerivation
}

type DateDerivation int

type DeathEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type DemotionEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type DepartureEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type DivorceEvent struct {
	GeneralEvent
	GeneralUnionEvent
}

type EconomicStatusEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type EnlistmentEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type EventDateType string

type EventMatcher func(TimelineEvent) bool

type EventParticipant struct {
	Person *Person
	Role   EventRole
}

type EventRole string

type Fact struct {
	Category  string
	Detail    string
	Comment   string // an explanatatory comment to be used alongside or as a footnote to the title
	Citations []*GeneralCitation
}

type Family struct {
	ID string // canonical id
	// Page                string   // path to page in site
	Tags                []string // tags to add to the person's page
	PreferredUniqueName string   // name used to identify the family
	Father              *Person
	Mother              *Person
	Children            []*Person
	BestStartEvent      TimelineEvent // event that best represents the start of the family unit if the bond is a marriage type
	BestEndEvent        TimelineEvent // event that best represents the end of the family unit if the bond is a marriage type

	BestStartDate *Date // date that best represents the start of the family unit
	BestEndDate   *Date // date that best represents the end of the family unit

	Timeline       []TimelineEvent
	Bond           string  // the kind of bond between the parents in the family
	EndReason      string  // the reason the family unit ended
	EndDeathPerson *Person // the person whose death ended the family unit, if any

	PublishChildren bool // true if this family's children should always be included in the publish set
}

type FeatureImage struct {
	MediaObject MediaObject
	Crop        *Region
}

type Gender string

type GeneralCitation struct {
	Date              *Date
	Source            *Source
	Detail            string
	ID                string
	GrampsID          string // the original gramps id, if any
	TranscriptionDate *Date
	TranscriptionText []Text
	Comments          []Text
	ResearchNotes     []Text
	URL               *Link
	MediaObjects      []*CitedMediaObject
	EventsCited       []TimelineEvent
	PeopleCited       []*Person
	Redacted          bool       // true if the citation's details should be redacted
	LastUpdated       *time.Time // time of last update, if known
}

type GeneralEvent struct {
	Date       *Date
	Place      *Place
	Title      string // used for the return value of "What()"
	Detail     string
	Citations  []*GeneralCitation
	Inferred   bool
	Narrative  Text // hand written narrative, if any
	Attributes map[string]string
}

type GeneralIndividualEvent struct {
	Principal         *Person
	OtherParticipants []*EventParticipant
}

type GeneralMultipartyEvent struct {
	Participants []*EventParticipant
}

type GeneralUnionEvent struct {
	Husband           *Person
	Wife              *Person
	OtherParticipants []*EventParticipant
}

type GeoLocation struct {
	Latitude  float64 // latitude of the centre in decimal degrees, +ve is east of meridian, -ve is west
	Longitude float64 // longitude of the centre in decimal degrees, +ve is north of equator, -ve is south
}

type IndividualNarrativeEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type IndividualTimelineEvent interface {
	TimelineEvent
	GetPrincipal() *Person
}

type Inference struct {
	Type   string
	Value  string
	Reason string
}

type InstitutionDepartureEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type InstitutionEntryEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type InstitutionEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type Interval struct {
	Interval gdate.Interval
}

type IrregularWhater interface {
	PassiveWhat() string                         // text description of what happened, a passive verb in the past tense, such as "was married", "was born", "died"
	ConditionalWhat(adverb string) string        // text description of what happened, an active verb in the past tense with a conditonal, such as "probably married", "probate probably granted"
	PassiveConditionalWhat(adverb string) string // text description of what happened, a passive verb in the past tense with a conditonal, such as was "was probably married", "probate was probably granted"
	PresentPerfectWhat() string                  // text description of what happened, a passive verb in the present perfect tense, usually prefixed by "inferred to ", such as "[inferred to ]have been married", "[inferred to ]have died"
	PastPerfectWhat() string                     // text description of what happened, a passive verb in the past perfect tense, such as "had been married", "had died"
}

type Link struct {
	Title string
	URL   string
}

type MarriageBannsEvent struct {
	GeneralEvent
	GeneralUnionEvent
}

type MarriageEvent struct {
	GeneralEvent
	GeneralUnionEvent
}

type MarriageLicenseEvent struct {
	GeneralEvent
	GeneralUnionEvent
}

type MediaObject struct {
	ID          string
	Title       string
	SrcFilePath string
	FileName    string
	FileSize    int
	MediaType   string
	Width       int
	Height      int
	Citations   []*GeneralCitation
	Redacted    bool // true if the object's details should be redacted
}

type MemorialEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type ModeOfDeath string

type MultipartyTimelineEvent interface {
	TimelineEvent
	GetPrincipals() []*Person
}

type MusterEvent struct {
	GeneralEvent
	GeneralMultipartyEvent
}

type Name struct {
	Name      string
	Citations []*GeneralCitation
}

type ObjectLink struct {
	Object any
	Start  int // rune index
	End    int // rune index
}

type Occupation struct {
	Date        *Date
	StartDate   *Date
	EndDate     *Date
	Place       *Place
	Name        string // the name of the occupation, to be used in a sentence as `a {name}`
	Comment     string // an explanatatory comment to be used alongside or as a footnote to the title
	Detail      string
	Status      OccupationStatus
	Group       OccupationGroup
	Citations   []*GeneralCitation
	Occurrences int
	Unknown     bool
}

type OccupationEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type OccupationGroup string

type OccupationStatus string

type POV struct {
	Person *Person // the person observing or experiencing the event
	Place  *Place  // the place in which the observing is taking place
}

type Person struct {
	ID                        string    // canonical identifier
	Tags                      []string  // tags to add to the person's page
	PreferredFullName         string    // full legal name
	PreferredGivenName        string    // name that can be used in prose, usually just the first name
	PreferredFamiliarName     string    // name that can be used in prose, usually just the first name or a nickname
	PreferredFamiliarFullName string    // full name using just the first name or a nickname
	PreferredFamilyName       string    // family name, or surname
	PreferredSortName         string    // name organised for sorting, generally as surname, forenames
	PreferredUniqueName       string    // a name with additional uniquely identifying information such as years of birth and death or a numeric identifier
	NickName                  string    // a name other than their given name that the are known by
	KnownNames                []*Name   // list of all known names
	FamilyNameGrouping        string    // the group of surnames this person's name is part of (e.g. Clarke/Clark), by default is the PreferredFamilyName
	Olb                       string    // One line bio
	Gender                    Gender    // male, female or unknown
	RelationToKeyPerson       *Relation // optional relation to the key person in the tree
	Father                    *Person
	Mother                    *Person
	ParentFamily              *Family                 // the family that this person is a child in
	Spouses                   []*Person               // list of people this person was in a relationship with
	Children                  []*Person               // list of people this person was considered a parent to
	Families                  []*Family               // list of families this person participated in as a parent
	VitalYears                string                  // best guess at year of birth and death in yyyy-yyyy format
	BestBirthlikeEvent        IndividualTimelineEvent // event that best represents the person's birth
	BestDeathlikeEvent        IndividualTimelineEvent // event that best represents the person's death
	Timeline                  []TimelineEvent
	BeingTense                string // tense to use when refering to person: 'is' if they are possibly alive, 'was' if they are dead

	Historic      bool // true if this person lived in a period more than a lifespan before the present (more than 120 years ago)
	PossiblyAlive bool // true if this person is possibly still alive, false if they are known to be dead or are historic
	DiedYoung     bool // true if this person died before adulthood

	Unknown            bool          // true if this person is known to have existed but no other information is known
	Unmarried          bool          // true if it is known that the person did not marry
	Childless          bool          // true if it is known that the person did not have any children
	Illegitimate       bool          // true if it is known that the person was born illegitimately
	BornInWorkhouse    bool          // true if the birth place of the person was a workhouse
	DiedInWorkhouse    bool          // true if the death place of the person was a workhouse
	Pauper             bool          // true if the person was, at some stage, noted as a pauper
	Twin               bool          // true if it is known that the person was a twin
	Blind              bool          // true if it is known that the person was blind for the majority of their life
	Deaf               bool          // true if it is known that the person was deaf for the majority of their life
	PhysicalImpairment bool          // true if it is known that the person was physically impaired for the majority of their life
	MentalImpairment   bool          // true if it is known that the person was mentally impaired for the majority of their life
	DiedInChildbirth   bool          // true if it is known that the person died in childbirth
	ModeOfDeath        ModeOfDeath   // mode of death, if known
	CauseOfDeath       *Fact         // cause of death, if known
	Publish            bool          // true if this person should always be included in the publish set
	Featured           bool          // true if this person is to be highlighted as a featured person on the tree overview
	Puzzle             bool          // true if this person is the centre of a significant puzzle
	Occupations        []*Occupation // list of occupations
	PrimaryOccupation  string        // simple description of main occupation
	OccupationGroup    OccupationGroup
	WikiTreeID         string // the wikitree id of this person
	GrampsID           string // the gramps id of this person
	Slug               string // a short url-friendly identifier that can be used to refer to this person
	Links              []Link // list of links to more information relevant to this person

	Redacted           bool                // true if the person's details should be redacted
	RedactionKeepsName bool                // true if this person's name should be kept during redaction
	Inferences         []Inference         // list of inferences made
	Anomalies          []*Anomaly          // list of anomalies detected
	ToDos              []*ToDo             // list of todos detected
	MiscFacts          []Fact              // miscellaneous facts
	Associations       []Association       // general associations with other people such as godparent or twin
	FeatureImage       *CitedMediaObject   // an image that can be used to represent the person
	ResearchNotes      []Text              // research notes associated with this person
	Comments           []Text              // comments associated with this person
	Gallery            []*CitedMediaObject // images and documents associated with the person

	LastUpdated *time.Time // time of last update
}

type PersonActionFunc func(*Person) (bool, error)

type PersonMatcher func(*Person) bool

type Place struct {
	ID           string   // canonical identifier
	Tags         []string // tags to add to the place's page
	OriginalText string   // the original text that was used to fill in the place information
	Hints        []place.Hint

	Name                  string       // the bare name of the place, could be street name or country name
	PreferredName         string       // the minimum amount of context, such as "street, locality" or "locality, region"
	PreferredUniqueName   string       // fully parsed name but with just enough extra context to make it unique
	PreferredFullName     string       // the fully parsed name
	PreferredSortName     string       // name organised for sorting, generally as a reverse hierarchy of country, region, locality
	PreferredLocalityName string       // name excluding specific building or street, instead starting with locality, i.e. "locality, region"
	Parent                *Place       // the parent of this place in the administrative hierarchy
	PlaceType             PlaceType    // the type of place, such as "village", "town", "parish"
	Numbered              bool         // whether the place is a numbered building
	Singular              bool         // whether the place is a singular member of a group such as the register office or the barracks, not a named church.
	BuildingKind          BuildingKind // the kind of building, such as "church", "workhouse" or "register office"
	Timeline              []TimelineEvent
	Unknown               bool         // true if this place is known to have existed but no other information is known
	Links                 []Link       // list of links to more information relevant to this place
	GeoLocation           *GeoLocation // geographic location of the place

	CountryName  *place.PlaceName
	UKNationName *place.PlaceName

	Kind place.PlaceKind // the kind of place - DEPRECATED

	ResearchNotes []Text              // research notes associated with this place
	Comments      []Text              // comments associated with this place
	Gallery       []*CitedMediaObject // images and documents associated with the place

	LastUpdated *time.Time // time of last update, if known
}

type PlaceMatcher func(*Place) bool

type PlaceType string

type ProbateEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type PromotionEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type Region struct {
	Left   int
	Bottom int
	Width  int
	Height int
}

type Relation struct {
	From                  *Person
	To                    *Person
	CommonAncestor        *Person
	FromGenerations       int       // number of generations between the From person and CommonAncestor. 1 = common ancestor is parent of from
	ToGenerations         int       // number of generations between the To person and CommonAncestor. 1 = common ancestor is parent of to
	ClosestDirectRelation *Relation // if the To person does not share an ancestor with the From person, then this is the relation of From to a person who was the partner/spouse of a direct relation of To
	// ToSpouseGenerations   int       // number of generations between the To person and the spouse of SpouseRelation. 0 = spouse, 1 = parent of spouse
	SpouseRelation *Relation // the relationship of the To person to the spouse of the ClosestDirectRelation
	AncestorPath   []*Person // the list of direct ancestors between From and To
}

type Repository struct {
	ID        string // canonical id
	Name      string
	ShortName string
}

type RepositoryRef struct {
	Repository *Repository
	CallNo     string
}

type ResidenceRecordedEvent struct {
	GeneralEvent
	GeneralMultipartyEvent
}

type SaleOfPropertyEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}

type Source struct {
	ID                  string // canonical id
	Unknown             bool   // true if this source is known to have existed but no other information is known
	Title               string
	Author              string
	SearchLink          string // link to online search interface
	RepositoryName      string
	RepositoryLink      string
	RepositoryRefs      []RepositoryRef
	EventsCiting        []TimelineEvent
	Tags                []string
	IsCivilRegistration bool // indicates whether this source holds civil registration records such as births marriages and deaths
	IsCensus            bool // indicates whether this source holds census records
	IsUnreliable        bool // indicates whether this source is of dubious reliability
}

type Text struct {
	ID        string
	Title     string
	Text      string
	Formatted bool
	Markdown  bool
	Links     []ObjectLink
}

type Timeline struct {
	Events []TimelineEvent
}

type TimelineEvent interface {
	GetDate() *Date
	GetPlace() *Place
	GetDetail() string
	GetNarrative() Text
	GetCitations() []*GeneralCitation
	GetAttribute(name string) (string, bool)
	Type() string                    // name of the type of event, usually a single word
	What() string                    // text description of what happened, an active verb in the past tense, such as married, born, died
	When() string                    // text description of date
	Where() string                   // text description of place
	IsInferred() bool                // whether or not the event was inferred to exist, i.e. has no supporting evidence
	DirectlyInvolves(p *Person) bool // whether or not the event directly involves a person as a principal or party
	GetParticipants() []*EventParticipant
	GetParticipantsByRole(EventRole) []*EventParticipant
}

type ToDo struct {
	Category ToDoCategory
	Context  string
	Goal     string
	Reason   string
}

type ToDoCategory string

type UnionTimelineEvent interface {
	TimelineEvent
	GetHusband() *Person
	GetWife() *Person
	GetOther(p *Person) *Person // returns the first of party1 or party2 that is not p
}

type Whater interface {
	What() string
}

type WillEvent struct {
	GeneralEvent
	GeneralIndividualEvent
}