board

type AccessKey struct {
	ID        string
	HumanID   string
	Name      string
	Digest    string
	CreatedAt string
	ExpiresAt *string // nil: it doesn't expire
	RevokedAt *string
	// LastUsedAt is when the key, or a browser login or agent token it started, was last
	// used, recorded at most once a minute; nil before its first use.
	LastUsedAt *string
	// IdleSeconds, when set, makes the key expire only once unused: each recorded use
	// moves ExpiresAt this many seconds past the use.
	IdleSeconds *int64
}

type Acked struct {
	Board    string
	Position Position
}

type AgentWork struct {
	CurrentTask      *WorkingTask
	OpenTasks        int64
	OldestOpen       *TaskRef
	PostsWithoutTask int
	Nudges           bool
}

type Board struct {
	TaskPrefix *string
	TasksOpen  int64
	ID         string
	Name       string
	// Title is free text people read beside the name; nil when the board has none.
	Title    *string
	Template *string
	Charter  string
	Roles    map[string]rules.Role
	Policy   rules.Policy
	HeadSeq  int64
	HeadHash string
	// MessageCount and LastMessageAt describe the board's messages; the store keeps
	// them as messages are inserted. LastMessageAt is nil before the first message.
	MessageCount  int64
	LastMessageAt *string
	CreatedAt     string
	CreatedBy     string // member id of the creating human
	// Visibility is BoardOpen or BoardPrivate: who can see the board at all.
	Visibility      string
	Lifecycle       string
	AgentsAddPeople bool
}

type BrowserLogin struct {
	// ID names the login (ses_…) so its person can list and end it without its secret.
	ID          string
	TokenDigest string
	HumanID     string
	// KeyID is the access key that started the login, which it never outlives.
	KeyID string
	// StartedWith is how the login started: SessionFromLoginCode or SessionFromKey.
	StartedWith string
	CreatedAt   string
	ExpiresAt   string
}

type BrowserSession struct {
	ID          string
	KeyID       string
	KeyName     string
	StartedWith string
	CreatedAt   string
	ExpiresAt   string
}

type Change struct {
	TaskPrefix      *string
	AgentsAddPeople *bool
	// Title is the new title; an empty string removes it.
	Title  *string
	Policy *rules.PolicyChange
}

type CodePreview struct {
	Person    Human
	KeyID     string
	KeyName   string
	ExpiresAt string
}

type Config struct {
	ServerID string
	Mode     string // "local" or "team"
	JoinHost string // how join lines name this server: "localhost", "localhost:7411", a domain
}

type ConnectInput struct {
	Invite      string
	Handle      string
	DisplayName string
	KeyName     string
}

type Connected struct {
	Person Human
	Key    AccessKey
	Token  string
}

type CreationReceipt struct {
	DelegationID string
	Key          string
	RequestHash  string
	CreatedAt    string
	Joined       Joined
}

type CurrentSession struct {
	Session BrowserSession
	Person  Human
}

type DelegatedBoard struct {
	NewBoard
	Session, Harness, Role, AgentName string
	Key, RequestHash                  string
}

type Delegation struct {
	ID        string
	KeyID     string
	HumanID   string
	Name      string
	Digest    string
	CreatedAt string
	// EndedAt is when another delegation with the same key and name replaced it.
	EndedAt *string
}

type DeliveryChange struct {
	Board   Board
	Agent   Member
	Changed bool
}

type DeliverySetting struct {
	Mode string
	Seq  int64
}

type GuestJoinInput struct {
	Code    string
	KeyName string
	Name    string
	Harness string
}

type GuestJoined struct {
	Joined
	Person   Human
	Key      AccessKey
	KeyToken string
}

type Head struct {
	BoardID string
	Board   string // the board's name
	Seq     int64
}

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

type HiddenBoard struct {
	Lifecycle                         string
	CanArchive, CanRestore, CanDelete bool
	ID                                string
	CreatedAt                         string
	Creator                           Human
	People                            int
}

type Human struct {
	ID          string
	Name        string
	DisplayName *string
	Role        string // ServerAdmin, ServerMember or ServerGuest
	CreatedAt   string
	// RemovedAt is when an admin removed the person from the server, and RemovedBy that
	// admin's id; nil while they are on it. A removed person's handle is free again.
	RemovedAt *string
	RemovedBy *string
}

type JoinCode struct {
	ID         string
	BoardID    string
	CodeDigest string
	Role       string
	ExpiresAt  string
	CreatedAt  string
	CreatedBy  string
	RevokedAt  *string
	Kind       string  // CodePairing or CodeGuest
	Guest      *string // the guest's handle, for a guest code
	GuestID    *string // an existing guest's permanent person id at issuance
	UsedAt     *string // when a guest code was used
	UsedBy     *string // the member id of the agent a guest code made
}

type JoinCodeInput struct {
	Role  string
	TTL   time.Duration
	Guest string
}

type JoinInput struct {
	Code    string
	Board   string
	Role    string
	Name    string
	Harness string
	Session string
	// contains filtered or unexported fields
}

type Joined struct {
	Agent  Member
	Token  string
	View   View
	Reused bool
}

type KeyList struct {
	Person Human
	Keys   []KeyView
	// CurrentKeyID is the caller's key, and CurrentKeyPreviousUse when it was used
	// before the request, to a minute; nil on its first use.
	CurrentKeyID          string
	CurrentKeyPreviousUse *string
}

type KeyUsage struct {
	AccessKey
	BrowserSessions int
	AgentSeats      int
	// Delegations counts the machine delegations made with the key that haven't ended;
	// they work only while the key does.
	Delegations int
}

type KeyView struct {
	KeyUsage
	State string
}

type LifecycleResult struct {
	ID        string
	Lifecycle string
	Changed   bool
}

type Listing struct {
	ArchivedCount int
	Boards        []View
	// Hidden is filled only for a server admin listing every board.
	Hidden []HiddenBoard
}

type Log struct {
	Board     Board
	Events    []events.Event
	NextAfter *int64
}

type LoginCode struct {
	Code      string
	ExpiresAt string
}

type MachineCollection struct {
	Pending   bool
	ExpiresAt string
	PollEvery time.Duration
	Connected Connected
}

type MachineRequest struct {
	ID           string
	CodeDigest   string
	SecretDigest string
	Label        string // the name the machine gave itself; it names the key
	// Handle names the person the request is for: only their own key may decide it. It
	// may name nobody, and then nobody can.
	Handle        string
	RequestedFrom string // the client address the request came from
	CreatedAt     string
	ExpiresAt     string
	State         string // a MachineRequest state
	// DecidedBy is the person who approved or refused it, and DecidedKey the key they
	// did it with, which must still work when the machine collects its key.
	DecidedBy  *string
	DecidedKey *string
	DecidedAt  *string
	// KeyID is the key the machine collected, once it has.
	KeyID *string
	// Polls counts the machine's collection attempts while it waited.
	Polls int
}

type MachineRequestView struct {
	Request MachineRequest
	Person  Human
}

type Me struct {
	CurrentTask *TaskRef
	Human       *Human
	Agent       *Member
	Board       string
	Browser     bool
}

type Member struct {
	CurrentTask *TaskRef
	ID          string
	BoardID     string
	Name        string
	Kind        string
	Role        *string
	HumanID     string // the human, or the agent's owner
	Owner       *string
	Harness     *string
	TokenDigest *string
	// KeyID is the access key the agent's token came from, which it never outlives; nil
	// for a person, and for a guest's agent, which has no key behind it.
	KeyID    *string
	Access   string // rules.AccessAdmin or rules.AccessMember for a person, empty for an agent
	Status   string
	Cursor   int64
	JoinedAt string
	// Presence is what was last reported for an agent; read it with CurrentPresence.
	Presence Presence
	// PersonRole is the server role of the member's person, or an agent's owner, as the
	// store read it with the member.
	PersonRole string
	// Delivery is an agent's delivery mode as its person set it.
	Delivery DeliverySetting
	// Session is the harness session an agent was made for (`<harness>:<id>`), when its
	// join sent one; never shown or recorded on the board.
	Session *string
	// RemovedAt and RemovedBy say when a removed agent was removed and by whom
	// (RemovedByPerson, RemovedByOwner or RemovedByAdmin); nil for agents removed
	// before this was kept, and for everyone else.
	RemovedAt *string
	RemovedBy *string
}

type MemberList struct {
	Members   []Member
	CanRemove map[string]bool
}

type Mention struct {
	MemberID string `json:"id"`
	Kind     string `json:"kind"`
	Name     string `json:"name"`
	// Text is the mention as written: "@codex" or "@role:reviewer".
	Text string `json:"text"`
	// Wakes is true when the mention counts as addressing the agent.
	Wakes bool `json:"wakes"`
	// Reason says why an agent's mention doesn't wake it: MentionLimit or
	// MentionCannotRead. Nil otherwise.
	Reason *string `json:"reason"`
}

type Message struct {
	About      []TaskTag
	ID         string
	BoardID    string
	Seq        int64
	At         string
	SenderID   string
	To         []string
	Body       string
	ReplyTo    *string
	ReplyToSeq *int64
	// ReplyToFrom is the name of the member who sent the message this one replies to;
	// the store fills it when it reads a message.
	ReplyToFrom *string
	// ThreadRoot is the first message of the reply's thread; nil for a message that
	// replies to nothing. The store fills ThreadRootSeq when it reads a message.
	ThreadRoot    *string
	ThreadRootSeq *int64
	// ReplyCount and LastReplyAt describe the thread a message starts, counting only the
	// replies its reader may see. The service fills them for each reader.
	ReplyCount   int
	LastReplyAt  *string
	Urgent       bool
	ExpectsReply bool
	Redactions   []Redaction
	// Recipients are the member ids the message was addressed to when it was posted, in
	// the order it named them; nil for a message to all or a legacy message whose
	// recipients were not recorded. To distinguishes those cases.
	Recipients []string
	// Mentions are the members the body mentions, each once, in the order first mentioned.
	Mentions []Mention
	// Reactions are the reactions on the message as its reader sees them, in the set's
	// order. The service fills them for each reader.
	Reactions []ReactionCount

	// Sender fields, filled in by the store when it reads a message.
	SenderName    string
	SenderKind    string
	SenderRole    *string
	SenderOwner   *string
	SenderHuman   string
	SenderHarness *string
	// AgentOwners is how many people have agents on the board, when the message was read.
	AgentOwners int
}

type NewBoard struct {
	Name     string
	Title    string
	Template string
	Charter  string
	Preset   string
	// Visibility is BoardOpen or BoardPrivate; empty means open.
	Visibility string
}

type NewDelegation struct {
	Delegation Delegation
	Token      string
}

type NewJoinCode struct {
	JoinCode JoinCode
	Board    string
	Creator  Member
	Code     string
	Line     string
}

type NewKey struct {
	Key   KeyView
	Token string
}

type NewMessage struct {
	About        *[]string
	To           []string
	Body         string
	ReplyTo      *string
	Urgent       bool
	ExpectsReply bool
}

type NewServerInvite struct {
	Invite ServerInvite
	Secret string
}

type NewTask struct {
	Title, About string
	Start        bool
}

type Notifier interface {
	// Watch returns a channel closed at the key's next change. Call it before reading,
	// so a change between the read and the wait isn't missed.
	Watch(key string) <-chan struct{}
	// Changed wakes everyone watching the key.
	Changed(key string)
}

type People struct {
	Board  Board
	People []Person
}

type Person struct {
	Member Member
	Person Human
}

type Position struct {
	ReadUpTo int64
	Unread   int64
}

type Presence struct {
	State string // one of the Presence* states; empty for a person, or never reported
	Since string // when State began
	At    string // when it was last reported
	// Delivery is the agent's delivery mode (focused, all, humans or off; auto from an
	// older daemon) as last reported, or empty if none was. It doesn't run out with the
	// presence.
	Delivery string
}

type PresenceChange struct {
	BoardID  string
	Board    string // the board's name
	Agent    string
	MemberID string // the agent's seat; Agent is its name now, for display
	Presence Presence
}

type Principal struct {
	Human *Human
	Agent *Member
	// Delegation is a machine's delegation, which acts for its person only to list their
	// boards (ListBoards), give a session a seat (Join), and create a board with its
	// session seat (CreateDelegatedBoard); everything else
	// refuses it.
	Delegation *Delegation
	// Browser is set for a browser token, which acts as its human with the human's
	// permissions, except that it can't log in another browser.
	Browser bool
	// KeyID is the access key behind the caller: the person's own key, the key that
	// started their browser login, or the key the agent's token came from. Empty for an
	// agent from before keys were recorded.
	KeyID string
	// contains filtered or unexported fields
}

type PruneInput struct {
	DisconnectedFor time.Duration
	All             bool
	DryRun          bool
	Agents          []string
}

type Pruned struct {
	Input  PruneInput
	Agents []PrunedAgent
	Kept   []string
}

type PrunedAgent struct {
	Member Member
	Board  Board
	Owner  Human
	Since  string
	Hidden bool
	// contains filtered or unexported fields
}

type Reaction struct {
	MessageID string
	MemberID  string
	// Name is the reaction's name in the set, such as "thumbsup".
	Name string
	At   string
	// MemberName is filled in by the store when it reads a reaction.
	MemberName string
}

type ReactionCount struct {
	Name  string
	Emoji string
	By    []string
	Mine  bool
}

type ReadChange struct {
	BoardID  string
	Board    string // the board's name
	Agent    string
	MemberID string // the agent's seat; Agent is its name now, for display
	Cursor   int64
}

type ReadTx interface {
	TaskMessageCounts(boardID, taskID string, reader Member, readAll bool, since int64) (messages, threads, messagesSince int, err error)
	TaskBySelector(boardID, selector string) (Task, error)
	Tasks(boardID string) ([]Task, error)
	TasksByID(boardID string, ids []string) (map[string]Task, error)
	TaskPrefixOwner(prefix string) (string, error)
	NextTaskNumber(boardID string) (int64, error)
	// AccessKeyByDigest finds an access key by the digest of its secret, whether or not
	// it still works.
	AccessKeyByDigest(digest string) (AccessKey, error)
	// AccessKeyByID finds an access key by id.
	AccessKeyByID(id string) (AccessKey, error)
	// KeysOf lists a person's access keys, oldest first, whether or not they still work,
	// each with the browser logins it started that haven't expired at now and the agents
	// whose tokens came from it.
	KeysOf(humanID, now string) ([]KeyUsage, error)
	// HumanByID finds a human by id, whether or not they were removed from the server.
	HumanByID(id string) (Human, error)
	// HumanByName finds a human still on the server by handle; a removed person's
	// handle finds no one.
	HumanByName(name string) (Human, error)
	// HumanCount returns how many people this server has ever had, removed ones included.
	HumanCount() (int, error)
	// PeopleOnServer lists the people still on the server, oldest first.
	PeopleOnServer() ([]Human, error)
	// AdminCount returns how many admins the server has, not counting removed people.
	AdminCount() (int, error)
	// ServerInviteByDigest finds a server invite by the digest of its secret.
	ServerInviteByDigest(digest string) (ServerInvite, error)
	// MachineRequestByCode finds a machine request by the digest of its short code,
	// whatever its state.
	MachineRequestByCode(digest string) (MachineRequest, error)
	// MachineRequestBySecret finds a machine request by the digest of its collection
	// secret, whatever its state.
	MachineRequestBySecret(digest string) (MachineRequest, error)
	// BrowserLoginByDigest finds a browser login by the digest of its token, whether or
	// not it has expired.
	BrowserLoginByDigest(digest string) (BrowserLogin, error)
	// BrowserLoginByID finds a browser login by id, whether or not it has expired.
	BrowserLoginByID(id string) (BrowserLogin, error)
	// BrowserLoginsOf lists a human's browser logins that haven't expired at now, newest
	// first.
	BrowserLoginsOf(humanID, now string) ([]BrowserLogin, error)
	// BoardByName finds a board by name.
	BoardByName(name string) (Board, error)
	// BoardByID finds a board by id.
	BoardByID(id string) (Board, error)
	// BoardNameTaken reports whether a board already has this name.
	BoardNameTaken(name string) (bool, error)
	// BoardsOfHuman lists, by name, the boards the human is on: those where their own
	// membership is active.
	BoardsOfHuman(humanID string) ([]Board, error)
	// BoardsSeenBy lists, by name, every open board and every board the human is on.
	BoardsSeenBy(humanID string) ([]Board, error)
	// PrivateBoardsNotOn lists, oldest first, the private boards the human isn't on.
	PrivateBoardsNotOn(humanID string) ([]Board, error)
	// BoardCreation returns who may create boards: CreationMembers unless set.
	BoardCreation() (string, error)
	// AgentsAddPeople reports the server-wide gate, true unless disabled.
	AgentsAddPeople() (bool, error)
	// DelegatedCreation finds a committed creation receipt, including expired receipts.
	DelegatedCreation(delegationID, key string) (CreationReceipt, error)
	// WorkingJoinCodes lists a board's join codes that are neither revoked nor expired
	// at now, oldest first.
	WorkingJoinCodes(boardID, now string) ([]JoinCode, error)
	// MemberByTokenDigest finds the agent whose token has this digest.
	MemberByTokenDigest(digest string) (Member, error)
	// MemberByID finds a member of any board by id, whatever its status.
	MemberByID(id string) (Member, error)
	// SeatForSession finds the newest agent of the human on the board made for the
	// harness session (Member.Session), whatever its status. The human's id is part of
	// the lookup, so another person's seat with the same session string is never found.
	SeatForSession(boardID, humanID, session string) (Member, error)
	// DelegationByDigest finds a machine delegation by the digest of its token, whether
	// or not it still works.
	DelegationByDigest(digest string) (Delegation, error)
	// DelegationByID finds a machine delegation by id, whether or not it still works.
	DelegationByID(id string) (Delegation, error)
	// HumanMember finds a human's own membership of a board.
	HumanMember(boardID, humanID string) (Member, error)
	// MemberByName finds a member of a board by name.
	MemberByName(boardID, name string) (Member, error)
	// Members lists a board's members in the order they joined.
	Members(boardID string) ([]Member, error)
	// JoinCodeByDigest finds a join code by the digest of the code.
	JoinCodeByDigest(digest string) (JoinCode, error)
	// JoinCodeByID finds a join code by id.
	JoinCodeByID(id string) (JoinCode, error)
	// PersonAdded finds the latest person.added event for a person's member on a board,
	// with its seq, time and actor.
	PersonAdded(boardID, memberID string) (events.Event, error)
	// Events returns up to limit of a board's events after seq, oldest first.
	Events(boardID string, after int64, limit int) ([]events.Event, error)
	// Timeline returns up to q.Limit of the board's messages that reader may see and that
	// match q, oldest first. Reader may see every message when readAll is true, otherwise
	// those it sent or that are addressed to all, to it by name or to its role.
	Timeline(boardID string, reader Member, readAll bool, q TimelineQuery) ([]Message, error)
	// Inbox returns up to limit messages after the reader's cursor that it didn't send
	// and that are addressed to it or, when mentions is true, mention it with Wakes set,
	// oldest first.
	Inbox(reader Member, mentions bool, limit int) ([]Message, error)
	// CountUnread counts the messages after the reader's cursor that it didn't send: with
	// addressedOnly, only those Inbox returns, including waking mentions when allowed.
	CountUnread(reader Member, addressedOnly, mentions bool) (int64, error)
	// CountNeedsReply counts recorded questions to this person without their direct reply.
	CountNeedsReply(reader Member) (int64, error)
	// MessageByID finds a message, with its sender and the seq of the message it replies to.
	MessageByID(id string) (Message, error)
	// MessagesBySeq returns the board's messages among seqs, keyed by seq.
	MessagesBySeq(boardID string, seqs []int64) (map[int64]Message, error)
	// Thread returns up to limit replies after seq in the thread rootID starts that
	// reader may see, oldest first. readAll means as for Timeline.
	Thread(rootID string, reader Member, readAll bool, after int64, limit int) ([]Message, error)
	// ThreadCounts returns, for each of rootIDs whose thread has a reply reader may see,
	// how many such replies it has and when the newest was posted. readAll means as for
	// Timeline.
	ThreadCounts(reader Member, readAll bool, rootIDs []string) (map[string]ThreadCount, error)
	// Threads returns up to limit of the board's threads that have a reply reader may
	// see and whose first message reader may see too, the one with the newest such reply
	// first. Repliers counts only the replies reader may see. readAll means as for
	// Timeline.
	Threads(boardID string, reader Member, readAll bool, limit int) ([]ThreadInfo, error)
	// Reactions returns the reactions to each of messageIDs that has any, oldest first.
	Reactions(messageIDs []string) (map[string][]Reaction, error)
}

type Reading struct {
	Work     *AgentWork
	Board    Board
	Reader   Member
	Messages []Message
	// NextAfter and PrevBefore are set when more matching messages come after or before
	// the page; Inbox leaves PrevBefore unset.
	NextAfter  *int64
	PrevBefore *int64
}

type Receipt struct {
	Member Member
	State  string
	// Presence is an agent's presence when the receipt was read, never stored with it;
	// nil for a person.
	Presence *Presence
}

type ReceiptsReading struct {
	Board      Board
	Message    Message
	ToEveryone bool
	Available  bool
	Recipients []Receipt
}

type Redaction struct {
	Kind  string `json:"kind"`
	Count int    `json:"count"`
}

type Removal struct {
	Person          Human
	DryRun          bool
	KeysRevoked     int
	BrowserSessions int
	Agents          int
	Boards          int
	OwnersPassed    int
	// Unreachable lists the private boards no one is left on, by id.
	Unreachable []string
}

type RemovedAgent struct {
	Member Member
	Board  Board
	Owner  Human
	Hidden bool
}

type Replay struct {
	Tasks      bool
	AddPeople  bool
	Handle     string
	Name       string
	ID         string
	MessageID  string
	JoinCode   string
	OwnSeat    bool
	Lifecycle  string
	DeleteDone bool
	// AgentRemoval is an agent removed from the board Name names (by name or id).
	AgentRemoval bool
	// PruneAll is a prune across the server, which only a server admin may see again.
	PruneAll bool
}

type Reveals struct {
	Messages int64
	Files    int64
}

type RoleChange struct {
	Person  Human
	Changed bool
}

type ServerInvite struct {
	ID        string
	Digest    string
	CreatedBy string // the admin's person id
	CreatedAt string
	ExpiresAt string
	UsedAt    *string
	UsedBy    *string
}

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

type SessionList struct {
	Person   Human
	Sessions []BrowserSession
}

type SessionStart struct {
	Code  string
	Key   string
	Token string
	// CurrentPersonID is the person whose working session the browser already has, if
	// any, and ConfirmSwitch whether its person confirmed signing in as someone else.
	CurrentPersonID string
	ConfirmSwitch   bool
}

type Settings struct {
	AgentsAddPeople *bool
	// BoardCreation is who may create boards: CreationMembers or CreationAdmins.
	BoardCreation string
}

type StartedMachineRequest struct {
	Code      string
	Secret    string
	ExpiresAt string
	PollEvery time.Duration
}

type StartedSession struct {
	Session BrowserSession
	Person  Human
	Token   string
}

type Store interface {
	// Read runs fn on a consistent view of the data and always rolls back.
	Read(ctx context.Context, fn func(ReadTx) error) error
	// Write runs fn and commits if it returns nil, rolling back otherwise. Writers run
	// one at a time, so a board's next seq can be read and appended without racing.
	Write(ctx context.Context, fn func(Tx) error) error
}

type Task struct {
	MessageCount, ThreadCount             int
	ID, Ref, BoardID, Board, Title, State string
	Number                                int64
	About, Stands                         *TaskText
	Owner                                 *Member
	Helpers                               []Member
	OpenedBy                              Member
	OpenedAt, UpdatedAt                   string
	ClosedAt, ClosedNote                  *string
}

type TaskDrop struct{ Member, Reason string }

type TaskFilter struct {
	Done, All, Mine bool
	State, Owner    string
	Limit           int
}

type TaskFinish struct {
	Note      string
	Cancelled bool
}

type TaskListing struct {
	Board  Board
	Tasks  []Task
	Counts map[string]int
	More   bool
}

type TaskPostReader interface {
	PostsWithoutTask(memberID string) (int, error)
}

type TaskRef struct{ ID, Ref, Title string }

type TaskTag struct {
	ID  string `json:"id"`
	Ref string `json:"ref"`
	How string `json:"how"`
}

type TaskText struct {
	Seq           int64
	MessagesSince int
	Text          string
	By            Member
	At            string
	Version       int64
}

type TaskUpdate struct {
	Title, About, Stands *string
	StandsBase           *int64
}

type ThreadCount struct {
	Replies int
	LastAt  string
}

type ThreadEntry struct {
	Root Message
	// Participants are the first message's sender, then each replier in the order they
	// first replied.
	Participants []string
}

type ThreadInfo struct {
	RootID   string
	Repliers []string
}

type ThreadList struct {
	Board   Board
	Reader  Member
	Threads []ThreadEntry
	// More is set when limit cut the list short.
	More bool
}

type ThreadReading struct {
	Board  Board
	Reader Member
	// Root is the thread's first message; nil when the reader may not see it.
	Root    *Message
	Replies []Message
	// NextAfter is set when more replies the reader may see come after the page.
	NextAfter *int64
}

type TimelineFilter struct {
	Task string
	// After and Before bound the seq window, exclusive at both ends.
	After, Before int64
	// Newest fills the page from the newest matching messages instead of the oldest.
	Newest bool
	Limit  int
	// From is the sender's member name, without @.
	From string
	// Role is the sender's role.
	Role string
	// ToMe keeps messages addressed to the caller that it didn't send.
	ToMe bool
}

type TimelineQuery struct {
	TaskID string
	// After and Before bound the seq window, exclusive at both ends.
	After, Before int64
	// Newest fills the page from the newest matching messages instead of the oldest.
	Newest bool
	Limit  int
	// FromID keeps messages sent by this member.
	FromID string
	// SenderRole keeps messages sent by members with this role.
	SenderRole string
	// ToMe keeps messages addressed to the reader (all, its role or @its name) that it
	// didn't send.
	ToMe bool
}

type Tx interface {
	SaveTask(Task) error
	ReserveTaskPrefix(boardID, prefix string) error
	SetTaskPrefix(boardID, prefix string) error
	SetCurrentTask(memberID string, ref *TaskRef) error
	ClearTaskCurrent(taskID string) error
	ClearMemberTask(memberID, taskID string) error
	ReadTx
	// InsertHuman adds a human, whose handle no other human still on the server has.
	InsertHuman(h Human) error
	// SetHumanRole sets a person's server role.
	SetHumanRole(id, role string) error
	// RemoveHuman marks a person removed from the server at a time, by an admin.
	RemoveHuman(id, at, by string) error
	// InsertAccessKey adds an access key.
	InsertAccessKey(k AccessKey) error
	// NameUnnamedKeys gives every access key with an empty name this name.
	NameUnnamedKeys(name string) error
	// RevokeAccessKey marks an access key revoked at a time; a revoked key keeps its
	// first time.
	RevokeAccessKey(id, at string) error
	// UseAccessKey records that an access key was used at a time, and moves its expiry
	// to expires when that isn't nil.
	UseAccessKey(id, at string, expires *string) error
	// InsertServerInvite adds a server invite.
	InsertServerInvite(i ServerInvite) error
	// UseServerInvite marks an unused invite used at a time by a person. It reports
	// false, changing nothing, when the invite was already used.
	UseServerInvite(id, at, humanID string) (bool, error)
	// InsertMachineRequest adds a machine request.
	InsertMachineRequest(r MachineRequest) error
	// DeleteEndedMachineRequests removes the machine requests whose ExpiresAt is at or
	// before now.
	DeleteEndedMachineRequests(now string) error
	// DecideMachineRequest moves a pending machine request to state (approved or
	// refused), by a person with one of their keys, at a time. It reports false,
	// changing nothing, when the request wasn't pending.
	DecideMachineRequest(id, state, humanID, keyID, at string) (bool, error)
	// CountMachineRequestPoll counts one more collection attempt on a machine request.
	CountMachineRequestPoll(id string) error
	// CollectMachineRequest marks an approved machine request collected with the key
	// made for it. It reports false, changing nothing, when the request wasn't approved
	// or was already collected.
	CollectMachineRequest(id, keyID string) (bool, error)
	// InsertBrowserLogin adds a browser login.
	InsertBrowserLogin(l BrowserLogin) error
	// DeleteBrowserLogins removes every browser login of a human and returns how many
	// of them had not expired at now.
	DeleteBrowserLogins(humanID, now string) (int, error)
	// DeleteBrowserLogin removes one browser login by id.
	DeleteBrowserLogin(id string) error
	// DeleteExpiredBrowserLogins removes the browser logins whose ExpiresAt is at or
	// before now.
	DeleteExpiredBrowserLogins(now string) error
	// InsertBoard adds a board.
	InsertBoard(b Board) error
	// SetBoardPolicy replaces a board's policy.
	SetBoardPolicy(boardID string, p rules.Policy) error
	// SetBoardAgentsAddPeople changes the board gate without altering its message policy.
	SetBoardAgentsAddPeople(boardID string, allowed bool) error
	// SetAgentsAddPeople changes the server-wide gate.
	SetAgentsAddPeople(allowed bool) error
	// SaveDelegatedCreation keeps the receipt in the resource's own transaction.
	SaveDelegatedCreation(receipt CreationReceipt) error
	// SetBoardTitle replaces a board's title; nil removes it.
	SetBoardTitle(boardID string, title *string) error
	// SetBoardVisibility makes a board BoardOpen or BoardPrivate.
	SetBoardVisibility(boardID, visibility string) error
	// SetBoardLifecycle preserves the board and its retained record.
	SetBoardLifecycle(boardID, lifecycle string) error
	// SetBoardCreation sets who may create boards.
	SetBoardCreation(v string) error
	// InsertMember adds a member to its board.
	InsertMember(m Member) error
	// SetMemberStatus sets a member's status: StatusActive, StatusLeft or StatusRemoved.
	SetMemberStatus(memberID, status string) error
	// RemoveAgent ends an agent's seat at a time, by RemovedByPerson, RemovedByOwner,
	// RemovedByAdmin or RemovedBySelf. The seat reads back as StatusRemoved, or
	// StatusLeft for RemovedBySelf, with RemovedAt and RemovedBy set.
	RemoveAgent(memberID, at, by string) error
	// SetAgentToken replaces an agent's token, so every earlier token stops working, and
	// the access key the new one stops with.
	SetAgentToken(memberID, digest, keyID string) error
	// InsertDelegation adds a machine delegation.
	InsertDelegation(d Delegation) error
	// EndDelegations ends, at a time, the delegations made with the key under the name
	// that haven't ended yet.
	EndDelegations(keyID, name, at string) error
	// SetMemberAccess sets a person's access on their board; it changes nothing for an
	// agent.
	SetMemberAccess(memberID, access string) error
	// SetCursor moves a member's read position forward; it never moves it back.
	SetCursor(memberID string, seq int64) error
	// SetPresence replaces an agent's presence.
	SetPresence(memberID string, p Presence) error
	// SetDelivery replaces an agent's delivery mode as its person set it.
	SetDelivery(memberID string, d DeliverySetting) error
	// InsertJoinCode adds a join code.
	InsertJoinCode(j JoinCode) error
	// RevokeJoinCode marks a join code revoked at a time; a revoked code keeps its first time.
	RevokeJoinCode(id, at string) error
	// UseJoinCode marks an unused join code used at a time, for the member it made. It
	// reports false, changing nothing, when the code was already used.
	UseJoinCode(id, at, memberID string) (bool, error)
	// AppendEvent adds the next event to its board's log and moves the board's head. It
	// fails, storing nothing, unless the event's seq is exactly one past the head.
	AppendEvent(e events.Event) error
	// InsertMessage adds a message and counts it on its board (MessageCount,
	// LastMessageAt).
	InsertMessage(m Message) error
	// InsertReaction adds a member's reaction to a message, which it hasn't made yet.
	InsertReaction(r Reaction) error
	// DeleteReaction removes a member's reaction to a message, if there is one.
	DeleteReaction(messageID, memberID, name string) error
}

type Unavailable struct {
	BoardID  string
	MemberID *string
}

type UnreadChange struct {
	BoardID  string
	Board    string // the board's name
	Position Position
}

type Update struct {
	Unavailable []Unavailable
	Heads       []Head
	Presence    []PresenceChange
	Reads       []ReadChange
	Unread      []UnreadChange
}

type View struct {
	CanArchive, CanRestore, CanDelete bool
	Board                             Board
	Creator                           Member
	// OnBoard is whether the caller is on the board, rather than seeing an open board
	// from outside.
	OnBoard bool
	// Position is the caller's read position on the board; nil when they aren't on it,
	// or when the read doesn't report it.
	Position *Position
	// NeedsReply is the person's unanswered question count; nil for other callers.
	NeedsReply *int64
	// PeopleCount and AgentCount are given to a machine's delegation: how many people
	// are on the board, and, where its person is on it, how many working agents.
	PeopleCount *int
	AgentCount  *int
	// Added is, for a person on the board, the person.added that someone else put them
	// on it with, while it is still new to them (addedBy); nil otherwise.
	Added *events.Event
}

type VisibilityChange struct {
	Board         string
	Before, After string
	Changed       bool
	DryRun        bool
	Reveals       *Reveals // set for private to open
	CodesCanceled int
}

type WorkingTask struct {
	TaskRef
	Owner  bool
	Stands *TaskText
}