acl

type Change struct {
	Class   Class
	Op      Op
	Section string // acls, grants, "acls+grants" for access rules that are in both, a section name, or an unknown section's name
	Key     string // the entry's key, or a summary of the atom or assertion
	Old     Text   // the canonical value on the old side (empty when added)
	New     Text   // and on the new side (empty when removed)
	Fields  []FieldDelta
	// OldN and NewN count a repeated entry on each side (tests, SSH rules); 0 when the
	// section has no repeats to count.
	OldN, NewN int
	// Note is a constant sentence that qualifies the change.
	Note string
	// OldPointer and NewPointer are JSON Pointers into each text, and OldLine and NewLine
	// the lines, for what the change names; empty or 0 when there is none.
	OldPointer, NewPointer string
	OldLine, NewLine       int
}

type Class string

type Code string

type Counts struct {
	Defaults, TestsReduced, Widening, TailscaleWritten, Semantic int
	CommentOnly, FormatOnly                                      int
}

type DiffOptions struct {
	// Section lists only the changes in one section: a known section name in any case, or
	// "unknown" for the sections the table does not know.
	Section string
	// Cursor continues a listing from the NextChange of an earlier result of the same pair.
	Cursor string
	// PageSize is the most changes listed; 0 means DefaultPage.
	PageSize int
	// IgnoreTailscaleWritten leaves the Tailscale-written changes out of the list and out of
	// Equal; they are still counted.
	IgnoreTailscaleWritten bool
	// OldShow and NewShow are how a caller sees the text of the old and of the new policy:
	// whatever a result quotes of a side is cut after its Show has run, and the digest of a
	// cursor is of the normal forms as they show. A nil Show shows the text as it is.
	OldShow, NewShow Show
	// Seal keys the digest that ties a cursor to its comparison: it is given that digest and
	// returns a keyed one. A nil Seal leaves the digest unkeyed.
	Seal func(digest []byte) string
}

type DiffResult struct {
	// SemanticallyEqual is true only if the two normal forms are equal: no change of the
	// five classes, whatever the options. False can be a false "changed" (see
	// NormalFormLimits); true is exact.
	SemanticallyEqual bool
	// Equal is SemanticallyEqual once the changes IgnoreTailscaleWritten leaves out are left
	// out.
	Equal   bool
	Counts  Counts
	Changes []Change // the page
	// Matched is how many changes the section filter and the options select.
	Matched   int
	Truncated bool
	// NextChange continues the listing. It identifies the comparison it was issued for: the two
	// normal forms as the two sides show them (so it tells nothing about a policy that the result
	// does not), the section filter and the Tailscale-written option, and, with a Seal, a key
	// that only the holder of it can compute. It is not a secret and is not signed: it keeps a
	// listing from continuing on the wrong comparison, and nothing more.
	NextChange string
	// NormalFormLimits, NotChecked and the as-of date qualify the answer.
	NormalFormLimits     []string
	NotChecked           []string
	TailscaleWrittenAsOf string
	// Test counts on each side, in elements.
	TestsBefore, TestsAfter       int
	SSHTestsBefore, SSHTestsAfter int
	// Ops is the work the whole comparison spent, in the units of MaxWork.
	Ops int64
}

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

type Error struct {
	Code Code
	// Message says what is wrong and, where there is one, the fix. It may quote the input,
	// so a caller treats it as untrusted text.
	Message string
	// Line and Column place the error in the text (from 1, bytes); Line is 0 when the
	// error has no position.
	Line, Column int
}

type Failure struct {
	Src string
	Dst string
	// SSH: the failure is of an entry of sshTests, not tests.
	SSH bool
}

type FieldDelta struct {
	Field                  string
	Added, Removed         []string
	AddedMore, RemovedMore int
}

type Finding struct {
	Code FindingCode
	// Pointer is the JSON Pointer of the object that holds the key, cut at 1 KiB.
	Pointer string
	// Key and FirstKey are the two spellings, the later and the first (each cut at 1 KiB).
	Key, FirstKey string
	// Line and Column place the later key; FirstLine and FirstColumn the first.
	Line, Column           int
	FirstLine, FirstColumn int
	Keeps                  Keeps
}

type FindingCode string

type Keeps string

type Location struct {
	Match   Match
	Pointer string // JSON Pointer, cut at 1 KiB
	Line    int
	Column  int
}

type Match string

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

type Op string

type Order uint8

type Section struct {
	// Name is the spelling Tailscale documents; the server reads names without regard to
	// case.
	Name  string
	Shape Shape
	Order Order
	// StructElements says what a nested object in the section looks like to the server's
	// decoder: the rules of an array are structs, whose field names fold case; the entries
	// of a map are exact.
	StructElements bool
}

type SectionSummary struct {
	// Name is the section's name as the table spells it, or as an unknown section was first
	// written (cut at 1 KiB).
	Name  string
	Known bool
	State State
	// Count is the elements of an array section, the entries of a map, or 1 for a value.
	Count int
	// Scalar is the canonical value of a section that holds one (disableIPv4,
	// OneCGNATRoute, randomizeClientPort), cut at 1 KiB.
	Scalar string
}

type Shape uint8

type Show func(s string, need int) string

type State uint8

type Summary struct {
	// Sections are the known sections in table order, then the unknown ones by name (at most
	// MaxNames of them, the first by name; a section whose value is null is absent and has no
	// row).
	Sections []SectionSummary
	// Defined names, sorted and exact (each cut at 1 KiB, at most MaxNames of each; when a
	// list is cut it holds the first MaxNames in sorted order).
	Groups, TagOwners, Hosts, Postures, IPSets []string
	// SyncedGroups are the group names the policy refers to that it does not define in
	// groups: groups synced from an identity provider are written group:name@domain, and
	// can hold spaces and capitals. When the list is cut it holds the first MaxNames found
	// in the text, sorted. Names are compared as cut at 1 KiB.
	SyncedGroups []string
	// NamesTruncated: a list above was cut at MaxNames (the unknown sections too), or a
	// reference too long to read (over 4 KiB) was passed over.
	NamesTruncated bool
	// Tests and SSHTests are the numbers of elements of those sections.
	Tests, SSHTests int
	// Unknown are the sections the table does not know, in the order they were first written:
	// the unknown sections that have a row above, so at most MaxNames and none whose value is
	// null (Doc.UnknownSections lists every name, null or not).
	Unknown []string
}

type Text struct {
	Text      string
	Len       int
	Truncated bool
}