detect

type FamilyRule struct {
	Prefix  string
	Carries model.Category // what the rest of the name holds, if personal
	Hint    *Hint
}

type Hint struct {
	Category model.Category
	Severity model.Severity // zero means the category default
	Mask     string
	Rows     []model.RowMask // other masks for some rows of the column
	Note     string
	Source   string // e.g. "preset:woocommerce"
	Ignore   bool   // known not to hold personal data
	// Delete marks a cache the platform rebuilds, such as WordPress
	// transients: a copy should delete these rows whatever they hold. A
	// hint with Delete and no Category doesn't say what the data is, so
	// the subject is judged as if there were no hint.
	Delete bool
}

type KeyFamily struct {
	Pattern string
	Keys    []string // sorted
	Carries model.Category
	Hint    *Hint // from a preset rule
	// contains filtered or unexported fields
}

type KeyTemplate struct {
	Pattern string // e.g. um_cache_userdata_* or _transient_feed_*
	// Short is Pattern with runs of 1 to 3 digits replaced too. Those
	// become * only when several keys share the result.
	Short   string
	Carries model.Category // email or IP address when the varying part is one
	// contains filtered or unexported fields
}

type KeyWords struct {
	// Label says the key names a field: at most one of its words is
	// unknown, and it ends in a label word or has a lower-case word the
	// rules or field names use. Date of birth and shipping method are
	// labels; Jane Doe phone, John Street and Next of kin aren't.
	Label   bool
	Known   []string // its words the rules, field names and labels use, lower case, in order
	Unknown int      // its other words, numbers aside
}

type Leaf struct {
	// Path is the leaf's path as Walk gives it: keys that may be data are
	// "*", "[]" or "{}". For a key, it is the path of the object or array
	// that holds it. Path is valid only during the call.
	Path []string
	// Key is a key's own text, for LeafKey: a JSON or PHP string key
	// decoded, or a PHP integer key in decimal. Segment is what the key adds
	// to the paths below it: the key, a template of it, "*" or "[]".
	Key, Segment string
	// DataKey marks a key that is itself a value worth checking, such as an
	// email or IP address, which Walk reports as a value at path {}.
	DataKey bool
	// Value is a string decoded, JSON escapes resolved, and other leaves as
	// written: 12.50, true, 1 for PHP's b:1;, null or N. For a key, it is
	// the key.
	Value string
	Kind  LeafKind
}

type LeafKind int

type NameMatch struct {
	Category model.Category
	Words    string         // the words that matched, e.g. "first name"
	Severity model.Severity // zero means the category default
	Note     string
	// Password marks a name that says a password is stored here: values
	// that aren't hashes are then plain text or reversible encryption.
	Password bool
	// Messages marks text written between people, such as private
	// messages and notifications.
	Messages bool
}

type Profile struct {
	Values   int // all values seen, including empty ones
	NonEmpty int

	Email, EmailReserved int
	Phone, PhoneStrict   int
	IP                   int
	IBAN                 int
	Card, CardTest       int
	Hash, HexDigest      int
	HashFormats          map[string]int
	UserAgent            int
	PaymentID            int
	Date                 int
	Secrets              map[string]*SecretCount
	// SecretValues counts the values with at least one secret, once each.
	SecretValues int

	// Prose: values with spaces that are longer than a few words.
	Text, TextEmail, TextPhone, TextIP, TextCard int

	// Values that cannot be names or addresses: plain numbers, and code
	// identifiers such as App\Jobs\SendInvoice.
	Numeric, CodeLike int

	// Values that say a name match is wrong: on/off flags, field names
	// (billing_address_1, edit-address), placeholders and ACF field keys,
	// and the field's own name (as in translation tables and import
	// mappings).
	Flag, FieldName, Placeholder, Echo int
	// MaxDigits is the most digits any one value holds: an ID number or a
	// birth date has at least four.
	MaxDigits int

	// Values that back or rule out other judgements: hardware IDs
	// (Opaque), push notification tokens (Push), email addresses inside
	// URLs (Inline), URLs and paths (URL), cryptocurrency addresses
	// (Crypto), text with spaces and no merge tags (Spaced), and whole
	// numbers (Whole).
	Opaque, Push, Inline, URL, Crypto, Spaced, Whole int

	Structured int
	Paths      map[string]*Profile
	// contains filtered or unexported fields
}

type SecretCount struct {
	Live, Test, Unknown int
}

type SecretHit struct {
	Kind string
	Mode string
}

type Span struct {
	Start, End int
	Kind       string // one of the Span* kinds, or a caller's own
	// Detail says more: a secret's or a password hash's kind, "strict" or
	// "loose" for a phone number, "test" for a published test card number,
	// "reserved" for an email address at a domain reserved for examples, and
	// "placeholder" for a password in a URL that reads as an example.
	Detail string
	Mode   string // for secrets: live, test or "" when the format does not say
}

type SpanFinder struct {
	Kind string
	// Find finds spans in a value.
	Find func(s string) []Span
	// FindView, when set, finds spans in the value's TextView, by offsets of
	// its Text. FindSpans prefers it, and builds the view once for every
	// finder that has one. A copy of a built-in finder that is given a Find
	// of its own must have its FindView set to nil, or wrapped too, as Keep
	// wraps both.
	FindView func(v *TextView) []Span
}

type Subject struct {
	Table    string
	Column   string
	MetaKey  string
	Name     string   // the name to judge: the column name or the meta key
	DataType string   // information_schema DATA_TYPE; empty for meta keys
	Context  []string // words of the table name
	Hint     *Hint
	Sampled  bool // false when values were not read (--no-samples)

	Keys        int    // keys a pattern stands for, copied to the findings
	KeysPartial bool   // Keys is a lower bound
	Where       string // the subject is these rows only, copied to the findings
	// Setting marks a key of a settings table, which holds one value; an
	// empty value then means nothing is stored.
	Setting bool
	// Skipped marks a key left without values by a sampling limit; name
	// matches on it stay weak.
	Skipped bool
	// Labels marks a key of a translation table: it names a UI string, not
	// a field, so only its values are judged.
	Labels bool
}

type TextView struct {
	// Text is the value's text, as finders read it. Like the value, it
	// holds the data: never print it.
	Text string
	// contains filtered or unexported fields
}