jmapcore

type Account struct {
	Name                string         `json:"name"`
	IsPersonal          bool           `json:"isPersonal"`
	IsReadOnly          bool           `json:"isReadOnly"`
	AccountCapabilities map[string]any `json:"accountCapabilities"`
}

type AddedItem struct {
	ID    string `json:"id"`
	Index uint   `json:"index"`
}

type ChangesRequest struct {
	AccountID  string `json:"accountId"`
	SinceState string `json:"sinceState"`
	// MaxChanges is a ceiling, not a page size: a server that cannot answer
	// within it returns tooManyChanges rather than a truncated list, which
	// would tell the client it had seen everything.
	MaxChanges *uint `json:"maxChanges"`
}

type ChangesResponse struct {
	AccountID string `json:"accountId"`
	OldState  string `json:"oldState"`
	NewState  string `json:"newState"`
	// HasMoreChanges is always false here: this server answers a window whole
	// or refuses it, so there is never a remainder to fetch.
	HasMoreChanges bool     `json:"hasMoreChanges"`
	Created        []string `json:"created"`
	Updated        []string `json:"updated"`
	Destroyed      []string `json:"destroyed"`
}

type Comparator struct {
	Property    string `json:"property"`
	IsAscending *bool  `json:"isAscending"`
}

type CoreCapability struct {
	MaxSizeUpload         int64    `json:"maxSizeUpload"`
	MaxConcurrentUpload   int      `json:"maxConcurrentUpload"`
	MaxSizeRequest        int64    `json:"maxSizeRequest"`
	MaxConcurrentRequests int      `json:"maxConcurrentRequests"`
	MaxCallsInRequest     int      `json:"maxCallsInRequest"`
	MaxObjectsInGet       int      `json:"maxObjectsInGet"`
	MaxObjectsInSet       int      `json:"maxObjectsInSet"`
	CollationAlgorithms   []string `json:"collationAlgorithms"`
}

type Description struct {
	Kind    byte
	Entries []StateEntry
	// Extra carries account-wide positions that no folder owns.
	//
	// The threading sidecar is one: a merge renames the threadId of messages
	// across folders while touching no folder's markers, so an Email state
	// built from markers alone cannot see it -- and a client syncing Email
	// objects would keep the old conversation for ever (RFC 8620 §5.2 requires
	// the updated records; threadId is an Email property).
	//
	// A position rather than a digest, for the same reason the rest of this is
	// a description: Foo/changes diffs two states, and a hash cannot be
	// diffed.
	Extra []uint64
}

type Email struct {
	ID         string          `json:"id"`
	BlobID     string          `json:"blobId"`
	ThreadID   string          `json:"threadId"`
	MailboxIDs map[string]bool `json:"mailboxIds"`
	Keywords   map[string]bool `json:"keywords"`
	Size       uint32          `json:"size"`
	ReceivedAt string          `json:"receivedAt"`

	// Headers is every header field of the message, in the order it carries
	// them, with the raw value (§4.1.2.1). It is what a client falls back to
	// when it needs a field this type does not model and does not know the
	// name in advance.
	Headers []EmailHeader `json:"headers"`

	// Header-derived fields (§4.1.2).
	MessageID  []string       `json:"messageId"`
	InReplyTo  []string       `json:"inReplyTo"`
	References []string       `json:"references"`
	Sender     []EmailAddress `json:"sender"`
	From       []EmailAddress `json:"from"`
	To         []EmailAddress `json:"to"`
	CC         []EmailAddress `json:"cc"`
	BCC        []EmailAddress `json:"bcc"`
	ReplyTo    []EmailAddress `json:"replyTo"`
	Subject    *string        `json:"subject"`
	SentAt     *string        `json:"sentAt"`

	// Body (§4.1.4).
	BodyStructure *EmailBodyPart            `json:"bodyStructure,omitempty"`
	BodyValues    map[string]EmailBodyValue `json:"bodyValues"`
	TextBody      []EmailBodyPart           `json:"textBody"`
	HTMLBody      []EmailBodyPart           `json:"htmlBody"`
	Attachments   []EmailBodyPart           `json:"attachments"`
	HasAttachment bool                      `json:"hasAttachment"`
	Preview       string                    `json:"preview"`
}

type EmailAddress struct {
	Name  *string `json:"name"`
	Email string  `json:"email"`
}

type EmailAddressGroup struct {
	Name      *string        `json:"name"`
	Addresses []EmailAddress `json:"addresses"`
}

type EmailBodyPart struct {
	PartID      *string         `json:"partId"`
	BlobID      *string         `json:"blobId"`
	Size        uint32          `json:"size"`
	Name        *string         `json:"name"`
	Type        string          `json:"type"`
	Charset     *string         `json:"charset"`
	Disposition *string         `json:"disposition"`
	CID         *string         `json:"cid"`
	Language    []string        `json:"language"`
	Location    *string         `json:"location"`
	SubParts    []EmailBodyPart `json:"subParts,omitempty"`
}

type EmailBodyValue struct {
	Value string `json:"value"`
	// IsEncodingProblem reports that the part could not be decoded cleanly.
	IsEncodingProblem bool `json:"isEncodingProblem"`
	// IsTruncated must be true whenever the server returned less than the whole
	// part. A server may truncate; it may not do so silently.
	IsTruncated bool `json:"isTruncated"`
}

type EmailFilter struct {
	Operator string `json:"operator"`

	InMailbox          *string  `json:"inMailbox"`
	InMailboxOtherThan []string `json:"inMailboxOtherThan"`
	Before             *string  `json:"before"`
	After              *string  `json:"after"`
	MinSize            *uint32  `json:"minSize"`
	MaxSize            *uint32  `json:"maxSize"`
	HasKeyword         *string  `json:"hasKeyword"`
	NotKeyword         *string  `json:"notKeyword"`
	HasAttachment      *bool    `json:"hasAttachment"`

	// Text conditions need the full-text index. They are named here so a
	// request carrying one can be refused explicitly instead of being ignored,
	// which would return a confidently wrong result set.
	Text    *string  `json:"text"`
	From    *string  `json:"from"`
	To      *string  `json:"to"`
	Cc      *string  `json:"cc"`
	Bcc     *string  `json:"bcc"`
	Subject *string  `json:"subject"`
	Body    *string  `json:"body"`
	Header  []string `json:"header"`
}

type EmailGetRequest struct {
	GetRequest
	BodyProperties      *[]string `json:"bodyProperties"`
	FetchTextBodyValues bool      `json:"fetchTextBodyValues"`
	FetchHTMLBodyValues bool      `json:"fetchHTMLBodyValues"`
	FetchAllBodyValues  bool      `json:"fetchAllBodyValues"`
	// MaxBodyValueBytes is the client's own cap (§4.2.2). Zero means the client
	// stated none, which is not the same as asking for everything: the server's
	// ceiling still applies.
	MaxBodyValueBytes uint32 `json:"maxBodyValueBytes"`
}

type EmailHeader struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type EmailQueryRequest struct {
	QueryRequest
	Filter *EmailFilter `json:"filter"`
	Sort   []Comparator `json:"sort"`
}

type EmailSubmission struct {
	ID             string    `json:"id"`
	IdentityID     string    `json:"identityId"`
	EmailID        string    `json:"emailId"`
	ThreadID       string    `json:"threadId"`
	Envelope       *Envelope `json:"envelope"`
	SendAt         time.Time `json:"sendAt"`
	UndoStatus     string    `json:"undoStatus"`
	DeliveryStatus any       `json:"deliveryStatus"`
	DsnBlobIDs     []string  `json:"dsnBlobIds"`
	MdnBlobIDs     []string  `json:"mdnBlobIds"`
}

type Envelope struct {
	MailFrom SubmissionAddress   `json:"mailFrom"`
	RcptTo   []SubmissionAddress `json:"rcptTo"`
}

type FollowedBy struct {
	Result any
	Then   []Implicit
}

type GetRequest struct {
	AccountID string `json:"accountId"`
	// IDs nil means "every object of this type" (§5.1). The distinction from an
	// empty array, which means "none", is why this is a pointer.
	IDs        *[]string `json:"ids"`
	Properties *[]string `json:"properties"`
}

type GetResponse[T any] struct {
	AccountID string `json:"accountId"`
	// State is the object type's state string. A client passes it back to
	// Foo/changes; it is not comparable across types.
	State    string   `json:"state"`
	List     []T      `json:"list"`
	NotFound []string `json:"notFound"`
}

type HeaderForm string

type HeaderProperty struct {
	// Property is the name as the client wrote it, which is the key the answer
	// must come back under.
	Property string
	// Name is the header field name, matched case-insensitively.
	Name string
	// Form is the requested form; Raw when the client named none.
	Form HeaderForm
	// All requests every occurrence rather than the last one.
	All bool
}

type Identity struct {
	ID            string         `json:"id"`
	Name          string         `json:"name"`
	Email         string         `json:"email"`
	ReplyTo       []EmailAddress `json:"replyTo"`
	Bcc           []EmailAddress `json:"bcc"`
	TextSignature string         `json:"textSignature"`
	HTMLSignature string         `json:"htmlSignature"`
	MayDelete     bool           `json:"mayDelete"`
}

type Implicit struct {
	Name   string
	Result any
}

type Invocation struct {
	Name string
	Args json.RawMessage
	// CallID ties a response to the call that produced it and is what a
	// back-reference names.
	CallID string
}

type Limits struct {
	// BaseURL is the public origin clients reach the server on. It prefixes
	// every URL in the session resource, so a proxied deployment sets it to the
	// externally visible name, not the pod address.
	BaseURL               string
	MaxSizeUpload         int64
	MaxSizeRequest        int64
	MaxConcurrentRequests int
	MaxCallsInRequest     int
	MaxObjectsInGet       int
	MaxObjectsInSet       int
	// Sieve advertises RFC 9661; nil leaves it out.
	Sieve *SieveSession
	// Submission advertises Identity and EmailSubmission; nil leaves them out.
	Submission *SubmissionCapability
	// WebSocket advertises RFC 8887; nil leaves it out.
	WebSocket *WebSocketCapability
	// WebSocketTicket advertises the ticket extension with WebSocket, at the
	// session and the account level, where the client looks for both.
	WebSocketTicket bool
	// Vacation advertises VacationResponse; nil leaves it out.
	Vacation *VacationCapability
}

type MailCapability struct {
	MaxMailboxesPerEmail       *int     `json:"maxMailboxesPerEmail"`
	MaxMailboxDepth            *int     `json:"maxMailboxDepth"`
	MaxSizeMailboxName         int      `json:"maxSizeMailboxName"`
	MaxSizeAttachmentsPerEmail int64    `json:"maxSizeAttachmentsPerEmail"`
	EmailQuerySortOptions      []string `json:"emailQuerySortOptions"`
	MayCreateTopLevelMailbox   bool     `json:"mayCreateTopLevelMailbox"`
}

type Mailbox struct {
	ID string `json:"id"`
	// Name is the leaf name, not the path: hierarchy is expressed by ParentID,
	// so a client never has to know the server's delimiter.
	Name     string  `json:"name"`
	ParentID *string `json:"parentId"`
	// Role is the IANA-registered purpose ("inbox", "sent", …), null when the
	// mailbox has none.
	Role      *string `json:"role"`
	SortOrder uint32  `json:"sortOrder"`

	TotalEmails  uint32 `json:"totalEmails"`
	UnreadEmails uint32 `json:"unreadEmails"`
	TotalThreads uint32 `json:"totalThreads"`
	// UnreadThreads counts threads with at least one unread message.
	UnreadThreads uint32 `json:"unreadThreads"`

	MyRights     MailboxRights `json:"myRights"`
	IsSubscribed bool          `json:"isSubscribed"`
}

type MailboxFilter struct {
	// Operator is set only when the client sent an operator node, which is how
	// that case is detected.
	Operator string `json:"operator"`

	ParentID     *string `json:"parentId"`
	Name         *string `json:"name"`
	Role         *string `json:"role"`
	HasAnyRole   *bool   `json:"hasAnyRole"`
	IsSubscribed *bool   `json:"isSubscribed"`
}

type MailboxQueryRequest struct {
	QueryRequest
	Filter *MailboxFilter `json:"filter"`
	Sort   []Comparator   `json:"sort"`
}

type MailboxRights struct {
	MayReadItems   bool `json:"mayReadItems"`
	MayAddItems    bool `json:"mayAddItems"`
	MayRemoveItems bool `json:"mayRemoveItems"`
	MaySetSeen     bool `json:"maySetSeen"`
	MaySetKeywords bool `json:"maySetKeywords"`
	MayCreateChild bool `json:"mayCreateChild"`
	MayRename      bool `json:"mayRename"`
	MayDelete      bool `json:"mayDelete"`
	MaySubmit      bool `json:"maySubmit"`
}

type Method func(ctx context.Context, args json.RawMessage) (any, *MethodError)

type MethodEntry struct {
	Capability string
	Fn         Method
}

type MethodError struct {
	Type        string `json:"type"`
	Description string `json:"description,omitempty"`
	// Arguments names the request arguments the error is about, which
	// invalidArguments carries so a client can point at what it sent rather
	// than re-reading the whole call (RFC 8620 §3.6.2).
	Arguments []string `json:"arguments,omitempty"`
}

type QueryChangesResponse struct {
	AccountID     string      `json:"accountId"`
	OldQueryState string      `json:"oldQueryState"`
	NewQueryState string      `json:"newQueryState"`
	Removed       []string    `json:"removed"`
	Added         []AddedItem `json:"added"`
}

type QueryRequest struct {
	AccountID      string `json:"accountId"`
	Position       int    `json:"position"`
	Limit          *uint  `json:"limit"`
	CalculateTotal bool   `json:"calculateTotal"`
}

type QueryResponse struct {
	AccountID string `json:"accountId"`
	// QueryState identifies the result set. Whether it can be used for an
	// incremental update is stated by CanCalculateChanges, not assumed.
	QueryState          string   `json:"queryState"`
	CanCalculateChanges bool     `json:"canCalculateChanges"`
	Position            int      `json:"position"`
	IDs                 []string `json:"ids"`
	Total               *uint    `json:"total,omitempty"`
	Limit               *uint    `json:"limit,omitempty"`
}

type Quota struct {
	ID           string   `json:"id"`
	ResourceType string   `json:"resourceType"`
	Used         int64    `json:"used"`
	HardLimit    int64    `json:"hardLimit"`
	Scope        string   `json:"scope"`
	Name         string   `json:"name"`
	Types        []string `json:"types"`
	// Nullable per the RFC: a missing soft limit is null, never 0, which a
	// client would read as "no headroom at all".
	WarnLimit   *int64  `json:"warnLimit"`
	SoftLimit   *int64  `json:"softLimit"`
	Description *string `json:"description"`
}

type QuotaChangesResponse struct {
	AccountID         string    `json:"accountId"`
	OldState          string    `json:"oldState"`
	NewState          string    `json:"newState"`
	HasMoreChanges    bool      `json:"hasMoreChanges"`
	Created           []string  `json:"created"`
	Updated           []string  `json:"updated"`
	Destroyed         []string  `json:"destroyed"`
	UpdatedProperties *[]string `json:"updatedProperties"`
}

type Registry map[string]MethodEntry

type Request struct {
	// Using lists the capabilities this request relies on. Core is not
	// implicit: a method whose capability is absent is answered with
	// unknownMethod, which is what lets a server add capabilities without
	// changing how older clients behave.
	Using       []string          `json:"using"`
	MethodCalls []Invocation      `json:"methodCalls"`
	CreatedIDs  map[string]string `json:"createdIds,omitempty"`
}

type RequestError struct {
	Type   string
	Status int
	Detail string
	// Limit names the exceeded limit. §3.6.1 requires it on a limit problem,
	// since "too big" is useless without knowing which bound was hit.
	Limit string
}

type Response struct {
	MethodResponses []Invocation `json:"methodResponses"`
	// CreatedIDs is a pointer so a client that sent an empty map gets one back.
	CreatedIDs *map[string]string `json:"createdIds,omitempty"`
	// SessionState is the same value the session resource carries, so a client
	// can tell its cached session went stale without refetching it.
	SessionState string `json:"sessionState"`
}

type ResultReference struct {
	// ResultOf is the callId of the earlier invocation.
	ResultOf string `json:"resultOf"`
	// Name is the method name that invocation must have responded with. A
	// client states it so a call answered by "error" cannot be mistaken for a
	// result.
	Name string `json:"name"`
	// Path is a JSON Pointer (RFC 6901) into that result, extended by "*".
	Path string `json:"path"`
}

type SearchSnippet struct {
	EmailID string  `json:"emailId"`
	Subject *string `json:"subject"`
	Preview *string `json:"preview"`
}

type SearchSnippetGetRequest struct {
	AccountID string       `json:"accountId"`
	Filter    *EmailFilter `json:"filter"`
	EmailIDs  []string     `json:"emailIds"`
}

type SearchSnippetGetResponse struct {
	AccountID string          `json:"accountId"`
	List      []SearchSnippet `json:"list"`
	NotFound  []string        `json:"notFound"`
}

type Session struct {
	Capabilities    map[string]any     `json:"capabilities"`
	Accounts        map[string]Account `json:"accounts"`
	PrimaryAccounts map[string]string  `json:"primaryAccounts"`
	Username        string             `json:"username"`
	APIURL          string             `json:"apiUrl"`
	DownloadURL     string             `json:"downloadUrl"`
	UploadURL       string             `json:"uploadUrl"`
	EventSourceURL  string             `json:"eventSourceUrl"`
	State           string             `json:"state"`
}

type SetError struct {
	Type        string   `json:"type"`
	Description string   `json:"description,omitempty"`
	Properties  []string `json:"properties,omitempty"`
	// NotFound lists every missing blob of a blobNotFound (RFC 8621 §4.6).
	NotFound []string `json:"notFound,omitempty"`
	// ExistingID names the object an alreadyExists collided with (RFC 9661 §2.4).
	ExistingID string `json:"existingId,omitempty"`
	// MaxSize, MaxRecipients and InvalidRecipients go with tooLarge,
	// tooManyRecipients and invalidRecipients (RFC 8621 §7.5).
	MaxSize           *int64   `json:"maxSize,omitempty"`
	MaxRecipients     *int     `json:"maxRecipients,omitempty"`
	InvalidRecipients []string `json:"invalidRecipients,omitempty"`
}

type SetRequest struct {
	AccountID string `json:"accountId"`
	// IfInState is the state the client believes the account is in. A pointer
	// because absent means "apply regardless", which is not the same as an
	// empty string a client could send deliberately.
	IfInState *string                    `json:"ifInState"`
	Create    map[string]json.RawMessage `json:"create"`
	Update    map[string]json.RawMessage `json:"update"`
	Destroy   []string                   `json:"destroy"`
}

type SetResponse struct {
	AccountID string `json:"accountId"`
	// OldState is what the state was before this call, NewState after it. A
	// client uses the pair to know whether anything else changed in between.
	OldState     string               `json:"oldState"`
	NewState     string               `json:"newState"`
	Created      map[string]any       `json:"created"`
	Updated      map[string]any       `json:"updated"`
	Destroyed    []string             `json:"destroyed"`
	NotCreated   map[string]*SetError `json:"notCreated"`
	NotUpdated   map[string]*SetError `json:"notUpdated"`
	NotDestroyed map[string]*SetError `json:"notDestroyed"`
}

type SieveCapability struct {
	MaxSizeScriptName   int      `json:"maxSizeScriptName"`
	MaxSizeScript       *int     `json:"maxSizeScript"`
	MaxNumberScripts    *int     `json:"maxNumberScripts"`
	MaxNumberRedirects  *int     `json:"maxNumberRedirects"`
	SieveExtensions     []string `json:"sieveExtensions"`
	NotificationMethods []string `json:"notificationMethods"`
	ExternalLists       []string `json:"externalLists"`
}

type SieveScript struct {
	ID       string `json:"id"`
	Name     string `json:"name"`
	BlobID   string `json:"blobId"`
	IsActive bool   `json:"isActive"`
}

type SieveSession struct {
	Implementation string
	Account        SieveCapability
}

type StateEntry struct {
	Key    [8]byte
	Fields []uint64
}

type SubmissionAddress struct {
	Email      string             `json:"email"`
	Parameters map[string]*string `json:"parameters"`
}

type SubmissionCapability struct {
	MaxDelayedSend       int                 `json:"maxDelayedSend"`
	SubmissionExtensions map[string][]string `json:"submissionExtensions"`
}

type Thread struct {
	ID string `json:"id"`
	// EmailIDs is ordered by receivedAt (§3). With one message per thread the
	// order is trivially satisfied.
	EmailIDs []string `json:"emailIds"`
}

type VacationCapability struct{}

type VacationResponse struct {
	ID        string  `json:"id"`
	IsEnabled bool    `json:"isEnabled"`
	FromDate  *string `json:"fromDate"`
	ToDate    *string `json:"toDate"`
	Subject   *string `json:"subject"`
	TextBody  *string `json:"textBody"`
	HTMLBody  *string `json:"htmlBody"`
}

type WebSocketCapability struct {
	URL          string `json:"url"`
	SupportsPush bool   `json:"supportsPush"`
}

type WebSocketTicketCapability struct {
	GenerationEndpoint string `json:"generationEndpoint"`
}