eas

type ApprovedApplication struct {
	Name string
	Hash string
}

type AutodiscoverOptions struct {
	// HTTPClient transports the discovery requests. If nil, http.DefaultClient.
	HTTPClient *http.Client
	// Logger receives debug events. If nil, slog.Default().
	Logger *slog.Logger
	// UserAgent is sent in the request header. Default "go-activesync/0.1".
	UserAgent string
	// Endpoints overrides the default endpoint candidates (e.g. for tests).
	// When nil, autodiscoverEndpointsFor is used.
	Endpoints []string
	// SkipHTTPRedirect disables option 3 (the HTTP GET fallback that
	// reads a 302 from autodiscover.<domain>). Useful in environments
	// where unauthenticated HTTP probes might be blocked.
	SkipHTTPRedirect bool
	// SkipSRVLookup disables option 4 (DNS SRV record fallback). Useful
	// when DNS is restricted or the lookup is too slow.
	SkipSRVLookup bool
	// SkipWellKnownFallback disables option 5 (the well-known EAS path
	// probe). When every schema-aware Autodiscover attempt fails, the
	// library tries HTTP OPTIONS against the canonical EAS endpoint at
	// the bare domain, autodiscover.<domain>, and mail.<domain>. This
	// handles deployments whose autodiscover responder does not speak the
	// EAS mobilesync request schema (e.g. SOGo, which historically only
	// implements the Outlook schema).
	SkipWellKnownFallback bool
	// SRVLookup is the DNS SRV resolver. Defaults to net.DefaultResolver.
	// Tests inject a stub.
	SRVLookup func(ctx context.Context, service, proto, name string) (string, []*net.SRV, error)
}

type AutodiscoverResult struct {
	URL            string // the EAS endpoint URL the server reports
	ServerHostname string // the bare hostname (informational)
	DisplayName    string // the user's display name, if reported
}

type BodyType int

type CalendarClient interface {
	SyncCalendar(ctx context.Context, folderID string, opts CalendarSyncOptions) (*CalendarSyncResult, error)
	CreateEvent(ctx context.Context, folderID string, draft EventDraft) (string, error)
	UpdateEvent(ctx context.Context, folderID, serverID string, draft EventDraft) error
	DeleteEvent(ctx context.Context, folderID, serverID string) error
	RespondInvite(ctx context.Context, folderID, serverID string, choice MeetingResponseChoice) (*MeetingResponseResult, error)
}

type CalendarSyncOptions struct {
	WindowSize  int
	DateFilter  FilterType
	NoBootstrap bool
}

type CalendarSyncResult struct {
	SyncKey       string
	MoreAvailable bool
	Added         []EventItem
	Changed       []EventItem
	Deleted       []string
}

type CertValidation struct {
	// Status is 1 (Success) when the certificate validates against the
	// server's trust chain. Other values per MS-ASCERT §2.2.4.74.
	Status int
}

type Client interface {
	EmailClient
	CalendarClient
	ContactsClient
	TasksClient
	NotesClient
	FolderClient
	SettingsClient
	SearchClient
	ProvisionClient
	PingClient

	// LastPolicy returns the most recently parsed Policy from a
	// Provision exchange on this client, or nil if no policy has been
	// received yet.
	LastPolicy() *Policy
}

type Config struct {
	// ServerURL is the EAS endpoint, e.g. "https://mail/Microsoft-Server-ActiveSync".
	// Required.
	ServerURL string
	// Username + Password are sent as HTTP Basic auth. Both required.
	Username string
	Password string
	// DeviceID is a 32-hex-char client identifier. Required; create once
	// per account and persist (the server treats a new ID as a new device).
	DeviceID string
	// DeviceType is sent in the URL query and policy doc. Default
	// "GoActiveSync". Some servers log this string in admin tools;
	// callers usually want to override with their app's name.
	DeviceType string
	// ASVersion is the protocol version sent in MS-ASProtocolVersion.
	// Default "14.1".
	ASVersion string
	// UserAgent is the HTTP User-Agent. Default "go-activesync/0.1".
	UserAgent string
	// HTTPClient is the transport. Default http.DefaultClient.
	HTTPClient *http.Client
	// Logger receives debug events. Default slog.Default().
	Logger *slog.Logger
	// State is required for stateful commands (Provision, Sync, FolderSync).
	State StateStore
	// Registry is the WBXML codepage registry. Default wbxml.DefaultRegistry().
	Registry *wbxml.Registry
	// AuthHeader, when set, overrides Username+Password for the
	// Authorization header. Called per request so callers can refresh
	// short-lived tokens (e.g. OAuth bearer) lazily. Return the full
	// header value, e.g. "Bearer eyJhbGc...". When unset, the client
	// uses HTTP Basic with Username:Password.
	AuthHeader func(ctx context.Context) (string, error)
	// RetryOn401 enables one transparent retry on a 401 Unauthorized
	// response, after a fresh AuthHeader call. Useful for OAuth bearer
	// flows where the token may have expired between requests.
	RetryOn401 bool
	// GzipRequests, when true, compresses request bodies above
	// GzipMinBytes with gzip and sets Content-Encoding accordingly.
	// Most EAS servers (Z-Push 2.5+, Exchange 2010+) accept this.
	GzipRequests bool
	// GzipMinBytes is the minimum body size that triggers compression
	// when GzipRequests is true. Default 1 KiB.
	GzipMinBytes int
	// Base64URL, when true, packs Cmd/User/DeviceId/DeviceType/PolicyKey
	// into a single base64-encoded query parameter per MS-ASHTTP §2.2.1.1.2.
	// Smaller request URLs and slightly faster server-side parsing on
	// some Exchange deployments. Off by default since Z-Push and SOGo
	// are happier with plain query strings.
	Base64URL bool
}

type ContactAddress struct {
	Street     string
	City       string
	State      string
	PostalCode string
	Country    string
}

type ContactDraft = ContactItem

type ContactItem struct {
	ServerID string

	FirstName  string
	LastName   string
	MiddleName string
	Title      string
	Suffix     string
	FileAs     string

	CompanyName    string
	Department     string
	JobTitle       string
	OfficeLocation string

	Email1Address string
	Email2Address string
	Email3Address string

	HomePhone     string
	BusinessPhone string
	MobilePhone   string

	HomeAddress     ContactAddress
	BusinessAddress ContactAddress

	Birthday    time.Time
	Anniversary time.Time

	WebPage string

	// Picture is base64-encoded JPEG bytes of the contact photo. The
	// server typically caps these at 36 KB. On round-trip the bytes are
	// base64-encoded for transport but stored decoded here.
	Picture []byte

	// Categories is the user's freeform list of tags ("Work", "Family").
	Categories []string

	// Contacts2 (12.x) extras.
	NickName     string
	IMAddress    string
	IMAddress2   string
	IMAddress3   string
	ManagerName  string
	GovernmentID string
	CustomerID   string
}

type ContactsClient interface {
	SyncContacts(ctx context.Context, folderID string) (*ContactsSyncResult, error)
	CreateContact(ctx context.Context, folderID string, draft ContactDraft) (string, error)
	UpdateContact(ctx context.Context, folderID, serverID string, draft ContactDraft) error
	DeleteContact(ctx context.Context, folderID, serverID string) error
}

type ContactsSyncResult struct {
	SyncKey       string
	MoreAvailable bool
	Added         []ContactItem
	Changed       []ContactItem
	Deleted       []string
}

type DayOfWeek int

type DeviceInformation struct {
	Model          string // device model name (e.g. "iPhone15,3")
	IMEI           string // device IMEI; rarely meaningful for non-phone clients
	FriendlyName   string // human-friendly device name
	OS             string // device operating system (e.g. "darwin/amd64")
	OSLanguage     string // ISO language tag
	PhoneNumber    string
	MobileOperator string
	UserAgent      string
	// EnableOutboundSMS reports whether the device can send SMS via the
	// EAS server's SMS bridge. False for non-phone clients.
	EnableOutboundSMS bool
}

type EASTimeZone struct {
	BiasMinutes  int32  // signed; the value Microsoft stores (UTC offset in negated minutes)
	StandardName string // up to 32 UTF-16 code units
	StandardDate SystemTime
	StandardBias int32
	DaylightName string
	DaylightDate SystemTime
	DaylightBias int32
}

type EmailChange struct {
	ServerID string
	// Read set to non-nil sets the Read flag. true=read, false=unread.
	Read *bool
	// Flagged set to non-nil sets the FlagStatus. true=2 (active),
	// false=0 (clear). Use SetFlagStatus for the full code.
	Flagged *bool
	// SetFlagStatus, when non-nil, sets the FlagStatus directly to the
	// EAS code (0=clear, 1=complete, 2=active). Overrides Flagged when
	// both are set.
	SetFlagStatus *int
	// Delete sends the change as a <Delete> rather than a <Change>.
	Delete bool
}

type EmailChangeResult struct {
	ServerID string
	Status   int
}

type EmailClient interface {
	SyncEmail(ctx context.Context, folderID string, opts EmailSyncOptions) (*EmailSyncResult, error)
	ApplyEmailChanges(ctx context.Context, folderID string, changes []EmailChange) ([]EmailChangeResult, error)
	FetchEmail(ctx context.Context, folderID, serverID string, opts FetchEmailOptions) (*EmailItem, error)
	SendMail(ctx context.Context, opts SendMailOptions) error
	SmartReply(ctx context.Context, opts ReplyForwardOptions) error
	SmartForward(ctx context.Context, opts ReplyForwardOptions) error
	SearchEmail(ctx context.Context, query string, opts EmailSearchOptions) (*EmailSearchResult, error)
	SearchEmailQuery(ctx context.Context, q Query, opts EmailSearchOptions) (*EmailSearchResult, error)
	FindEmail(ctx context.Context, query string, opts FindOptions) (*FindResult, error)
}

type EmailItem struct {
	ServerID string

	Subject      string
	From         string // raw "Name <addr>" form
	To           string // semicolon-separated, server's exact text
	Cc           string
	Bcc          string
	ReplyTo      string
	Sender       string
	DisplayTo    string
	DateReceived time.Time // zero if not parseable

	Read           bool
	FlagStatus     int // 0=clear, 1=complete, 2=active
	Importance     int // 0=low, 1=normal, 2=high
	HasAttachments bool
	ThreadTopic    string
	ConversationID []byte
	MessageClass   string

	BodyType          BodyType
	BodyEstimatedSize int
	BodyTruncated     bool
	Body              string // populated for BodyTypePlain / BodyTypeHTML / BodyTypeRTF
	BodyMIME          []byte // populated when BodyTypeMIME was requested
	BodyPreview       string // server-generated short preview, if any

	// Categories is the user's freeform tag list ("Work", "Family").
	Categories []string
	// VotingResponse is the recipient's vote on a voting-button mail
	// (Email2 codepage, 14.0+). Empty when the message has no buttons.
	VotingResponse string
	// VotingResponseOptions is the comma-separated list of available
	// vote choices the sender configured.
	VotingResponseOptions string
}

type EmailSearchOptions struct {
	// FolderID restricts the search to a single folder. Empty searches all
	// folders.
	FolderID string
	// DeepTraversal includes subfolders when FolderID is set.
	DeepTraversal bool
	// Range is the result window in EAS "<start>-<end>" form, inclusive
	// (e.g. "0-49" for the first 50 hits). Default "0-49".
	Range string
	// BodyPreviewBytes limits the per-hit body preview length. Default 256.
	BodyPreviewBytes int
	// RebuildResults forces the server to recompute its search index
	// rather than serving cached results. Off by default.
	RebuildResults bool
}

type EmailSearchResult struct {
	// Items in result order. ServerID is set from the LongId element.
	Items []EmailItem
	// Range echoes the server's reported result window.
	Range string
	// Total is the server's estimate of the total matching items.
	Total int
}

type EmailSyncOptions struct {
	WindowSize         int
	BodyType           BodyType
	BodyTruncationSize int
	DateFilter         FilterType
	NoBootstrap        bool
	// MIMESupport controls how the server returns MIME content:
	// 0=never (default), 1=for S/MIME only, 2=always.
	MIMESupport int
	// MIMETruncation, when >0, truncates the MIME blob to that many
	// bytes (different from BodyTruncationSize, which applies to the
	// AirSyncBase Body).
	MIMETruncation int
	// ConversationMode, when true, asks the server to deliver
	// conversation-grouped results (14.0+).
	ConversationMode bool
	// RightsManagementSupport, when true, includes IRM-protected items
	// in the response with the license metadata expanded (14.1+).
	RightsManagementSupport bool
	// BodyPart, when non-zero, requests a body-part preference
	// (a fragment of the body sized to the value, used for previews).
	BodyPartPreviewBytes int
	// Wait is the long-poll interval in minutes (1-59). When non-zero,
	// the server holds the request open until items are available or
	// Wait minutes elapse. Mutually exclusive with HeartbeatSeconds.
	WaitMinutes int
	// HeartbeatSeconds is the long-poll interval in seconds. EAS 14.0+
	// alternative to WaitMinutes with finer granularity. Mutually
	// exclusive with WaitMinutes.
	HeartbeatSeconds int
}

type EmailSyncResult struct {
	SyncKey       string
	MoreAvailable bool
	Added         []EmailItem
	Changed       []EmailItem
	Deleted       []string
}

type EventAttendee struct {
	Name           string
	Email          string
	AttendeeStatus int
	AttendeeType   int
}

type EventDraft struct {
	Subject     string
	Location    string
	Body        string
	StartTime   time.Time
	EndTime     time.Time
	AllDayEvent bool
	BusyStatus  int // 0=free, 1=tentative, 2=busy, 3=OOF, 4=working elsewhere
	Sensitivity int // 0=normal, 1=personal, 2=private, 3=confidential
	Reminder    int // minutes before; 0 = none
	Attendees   []EventAttendee
	// Recurrence sets a repeat rule; nil means single-instance.
	Recurrence *Recurrence
	// Exceptions list per-instance overrides for a recurring event.
	Exceptions []Exception
	// TimeZone is the EAS time zone blob. EncodeTimeZone(loc) builds
	// one from a Go *time.Location for the simple case. When zero,
	// no TimeZone element is sent (the server uses its default).
	TimeZone *EASTimeZone
	// TimeZoneRaw is an alternative way to specify the time zone:
	// supply the base64 string the server gave you on a previous
	// fetch (for byte-identical round-trip).
	TimeZoneRaw string
}

type EventItem struct {
	ServerID string
	UID      string

	Subject       string
	Location      string
	Body          string
	BodyType      BodyType
	StartTime     time.Time
	EndTime       time.Time
	AllDayEvent   bool
	BusyStatus    int
	Sensitivity   int
	MeetingStatus int
	Reminder      int

	OrganizerName  string
	OrganizerEmail string
	Attendees      []EventAttendee

	// Recurrence is the repeat rule, when set.
	Recurrence *Recurrence
	// Exceptions are per-instance overrides.
	Exceptions []Exception
	// TimeZone is the parsed Microsoft TIME_ZONE_INFORMATION blob.
	// Zero value means the server didn't include one (Outlook fills
	// this in for recurring events; one-shot events often omit it).
	TimeZone EASTimeZone
	// TimeZoneRaw is the original base64 text from the server, useful
	// for byte-identical round-trip when updating the event.
	TimeZoneRaw string
}

type Exception struct {
	// ExceptionStartTime is the original instance time being overridden.
	ExceptionStartTime time.Time
	// Deleted, when true, removes the instance entirely; the other
	// fields are ignored.
	Deleted bool
	// Subject etc. — when non-empty, override the recurring event's
	// values for this instance only.
	Subject     string
	Location    string
	StartTime   time.Time
	EndTime     time.Time
	AllDayEvent bool
	BusyStatus  int
	Reminder    int
	Body        string
}

type FetchAttachmentResult struct {
	// Data is the attachment payload (already gunzipped if Range was
	// not used).
	Data []byte
	// ContentType is the MIME type the server reported, when available.
	ContentType string
	// Range is the server-echoed byte range when partial fetch was
	// requested. Empty otherwise.
	Range string
}

type FetchEmailOptions struct {
	BodyType           BodyType // default BodyTypeMIME for full fidelity
	BodyTruncationSize int      // 0 = full body
}

type FilterType int

type FindHit struct {
	Item           EmailItem
	Preview        string
	HasAttachments bool
}

type FindOptions struct {
	// FolderID restricts the search to a single folder. Empty searches
	// the inbox by default per server policy.
	FolderID string
	// DeepTraversal includes subfolders when FolderID is set.
	DeepTraversal bool
	// Range is the result window in EAS "<start>-<end>" form, inclusive.
	// Default "0-49".
	Range string
	// PreviewBytes requests an HTML preview of each hit, up to N bytes.
	PreviewBytes int
}

type FindResult struct {
	Hits  []FindHit
	Range string
	Total int
}

type Folder struct {
	ServerID    string
	ParentID    string
	DisplayName string
	Type        FolderType
}

type FolderClient interface {
	FolderSync(ctx context.Context) (*FolderSyncResult, error)
	FolderCreate(ctx context.Context, parentID, displayName string, folderType FolderType) (*FolderCreateResult, error)
	FolderUpdate(ctx context.Context, serverID, newParentID, newDisplayName string) error
	FolderDelete(ctx context.Context, serverID string) error
	GetItemEstimate(ctx context.Context, folderIDs []string) ([]ItemEstimate, error)
	MoveItems(ctx context.Context, srcFolder, dstFolder string, ids []string) ([]MoveItemResult, error)
	MoveViaItemOperations(ctx context.Context, srcFolder, srcID, dstFolder string, moveAlways bool) (string, error)
	EmptyFolderContents(ctx context.Context, folderID string, deleteSubfolders bool) error
	FetchAttachment(ctx context.Context, fileReference string, rangeStart, rangeEnd int64) (*FetchAttachmentResult, error)
	FetchDocumentLibrary(ctx context.Context, linkID string, rangeStart, rangeEnd int64) ([]byte, error)
}

type FolderCreateResult struct {
	// ServerID is the new folder's server-assigned identifier.
	ServerID string
	// SyncKey is the new FolderSync key the server returns. Already
	// persisted in the StateStore by the helper.
	SyncKey string
	// Status is 1 on success.
	Status int
}

type FolderSyncResult struct {
	// SyncKey is the new key the server returned. Already persisted in the
	// StateStore by FolderSync; surfaced here for diagnostics.
	SyncKey string
	// Added are folders the server reports as new since the prior SyncKey.
	// On the first call (SyncKey "0") this is the entire folder hierarchy.
	Added []Folder
	// Updated are folders whose metadata changed (typically a rename or
	// reparent).
	Updated []Folder
	// Deleted are server IDs of folders the user removed.
	Deleted []string
}

type FolderType int

type GALEntry struct {
	DisplayName  string
	FirstName    string
	LastName     string
	Title        string
	Office       string
	Company      string
	Alias        string
	EmailAddress string
	Phone        string
	HomePhone    string
	MobilePhone  string
}

type GALSearchResult struct {
	Entries []GALEntry
	Range   string
	Total   int
}

type HTTPError struct {
	StatusCode int
	Status     string
	URL        string
	Body       []byte // truncated to 4 KiB
}

type ItemEstimate struct {
	CollectionID string
	Class        string
	Estimate     int
	Status       int
}

type MeetingResponseChoice int

type MeetingResponseResult struct {
	CalendarID string
	Status     int
}

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

type MoveItemResult struct {
	SrcServerID string
	DstServerID string // assigned by destination folder
	Status      int
}

type NoteDraft = NoteItem

type NoteItem struct {
	ServerID         string
	Subject          string
	Body             string
	BodyType         BodyType // typically Plain or HTML
	LastModifiedDate time.Time
	Categories       []string
}

type NotesClient interface {
	SyncNotes(ctx context.Context, folderID string) (*NotesSyncResult, error)
	CreateNote(ctx context.Context, folderID string, draft NoteDraft) (string, error)
	UpdateNote(ctx context.Context, folderID, serverID string, draft NoteDraft) error
	DeleteNote(ctx context.Context, folderID, serverID string) error
}

type NotesSyncResult struct {
	SyncKey       string
	MoreAvailable bool
	Added         []NoteItem
	Changed       []NoteItem
	Deleted       []string
}

type OofConfig struct {
	State                OofState
	StartTime            time.Time
	EndTime              time.Time
	InternalReply        OofMessage
	ExternalKnownReply   OofMessage
	ExternalUnknownReply OofMessage
}

type OofMessage struct {
	Enabled      bool
	ReplyMessage string
	BodyType     BodyType // BodyTypePlain or BodyTypeHTML
}

type OofState int

type OptionsResult struct {
	// ProtocolVersions are the EAS protocol versions the server supports
	// (e.g. ["2.5", "12.0", "12.1", "14.0", "14.1"]).
	ProtocolVersions []string
	// Commands are the EAS commands the server accepts (e.g. ["Sync",
	// "FolderSync", "Provision", ...]).
	Commands []string
}

type PingClient interface {
	Ping(ctx context.Context, heartbeatSeconds int, folders []PingFolder) (*PingResult, error)
}

type PingFolder struct {
	ID    string
	Class string
}

type PingResult struct {
	// Status is the EAS Ping status code (1=OK no changes, 2=changes
	// available, 3=heartbeat too short, 4=heartbeat too long, 5=too many
	// folders, 6=missing parameters, 7=folder hierarchy out of date,
	// 8=server error).
	Status int
	// ChangedFolders lists the folder IDs the server reports have
	// pending changes; populated when Status=2.
	ChangedFolders []string
	// HeartbeatInterval is the server-recommended heartbeat in seconds;
	// non-zero on Status 3 or 4 to indicate the acceptable range.
	HeartbeatInterval int
}

type Policy struct {
	// Password / lock policy.
	DevicePasswordEnabled              bool
	AlphanumericDevicePasswordRequired bool
	AllowSimpleDevicePassword          bool
	MinDevicePasswordLength            int
	MinDevicePasswordComplexCharacters int
	MaxDevicePasswordFailedAttempts    int
	MaxInactivityTimeDeviceLockSeconds int
	DevicePasswordExpirationDays       int
	DevicePasswordHistory              int
	RequireStorageCardEncryption       bool
	RequireDeviceEncryption            bool

	// Hardware feature toggles.
	AllowCamera           bool
	AllowStorageCard      bool
	AllowWiFi             bool
	AllowTextMessaging    bool
	AllowBluetooth        int // 0 disabled, 1 handsfree-only, 2 allowed
	AllowIrDA             bool
	AllowInternetSharing  bool
	AllowRemoteDesktop    bool
	AllowDesktopSync      bool
	AllowBrowser          bool
	AllowConsumerEmail    bool
	AllowPOPIMAPEmail     bool
	AllowUnsignedApps     bool
	AllowUnsignedInstall  bool
	RequireManualSyncRoam bool

	// Mail / calendar limits.
	AllowHTMLEmail                 bool
	MaxAttachmentSizeBytes         int
	MaxCalendarAgeFilter           int // EAS filter type
	MaxEmailAgeFilter              int
	MaxEmailBodyTruncationSize     int
	MaxEmailHTMLBodyTruncationSize int
	AttachmentsEnabled             bool

	// S/MIME.
	RequireSignedSMIMEMessages               bool
	RequireEncryptedSMIMEMessages            bool
	RequireSignedSMIMEAlgorithm              int
	RequireEncryptionSMIMEAlgorithm          int
	AllowSMIMEEncryptionAlgorithmNegotiation int
	AllowSMIMESoftCerts                      bool

	// Application allow/deny lists (parsed but rarely meaningful for us).
	UnapprovedInROMApplicationList []string
	ApprovedApplicationList        []ApprovedApplication

	// Hash is the policy revision hash; stable until the server changes
	// any field above. Useful for caching parsed policies across calls.
	Hash string
}

type ProvisionClient interface {
	Provision(ctx context.Context) error
	AcknowledgeRemoteWipe(ctx context.Context, status int) error
	NegotiateVersion(ctx context.Context) (string, error)
	Options(ctx context.Context) (*OptionsResult, error)
}

type Query interface {
	// contains filtered or unexported methods
}

type Recurrence struct {
	Type           RecurrenceType
	Interval       int       // every N days/weeks/months
	Until          time.Time // last instance; zero = forever
	Occurrences    int       // alternative to Until; 0 = unset
	DayOfWeek      DayOfWeek // for Weekly + Monthly/YearlyByDay
	DayOfMonth     int       // for MonthlyDate / YearlyDate
	WeekOfMonth    int       // 1-5 (5 = "last")
	MonthOfYear    int       // 1-12 for Yearly variants
	IsLeapMonth    bool      // 16.0+: lunar calendar quirk
	FirstDayOfWeek int       // 0=Sunday
	CalendarType   int       // 1=Gregorian etc.
}

type RecurrenceType int

type ReplyForwardOptions struct {
	SendMailOptions
	// FolderID and ServerID identify the source message being replied
	// to or forwarded.
	FolderID string
	ServerID string
}

type ResolveOptions struct {
	// CertificateRetrieval enables S/MIME cert lookup for each recipient.
	// 1=NoCertificate (default), 2=Full, 3=Mini.
	CertificateRetrieval int
	// MaxCertificates caps the cert count per recipient (default 99999).
	MaxCertificates int
	// MaxAmbiguousRecipients caps how many candidates an ambiguous name
	// returns. Default 100.
	MaxAmbiguousRecipients int
	// Availability requests free/busy data for each resolved recipient
	// in the given window. Both fields must be set to enable.
	AvailabilityStart time.Time
	AvailabilityEnd   time.Time
	// PictureMaxBytes requests a contact picture if non-zero.
	PictureMaxBytes int
}

type ResolveResponse struct {
	To         string
	Status     int
	Recipients []ResolvedRecipient
}

type ResolvedRecipient struct {
	// Type is 1=GAL, 2=ContactsFolder.
	Type         int
	DisplayName  string
	EmailAddress string
	// Certificates lists raw S/MIME certificate bytes (one per cert).
	Certificates [][]byte
	// MergedFreeBusy is the EAS free/busy string when Availability was
	// requested: each character is a 30-minute slot, "0"=free, "1"=tentative,
	// "2"=busy, "3"=OOF, "4"=workingElsewhere.
	MergedFreeBusy string
	// Picture, if requested and present.
	Picture []byte
}

type RightsLicense struct {
	Owner                            string
	ContentOwner                     string
	ContentExpiryDate                string // ISO 8601
	TemplateID                       string
	TemplateName                     string
	EditAllowed                      bool
	ReplyAllowed                     bool
	ReplyAllAllowed                  bool
	ForwardAllowed                   bool
	ModifyRecipientsAllowed          bool
	ExtractAllowed                   bool
	PrintAllowed                     bool
	ExportAllowed                    bool
	ProgrammaticAccessAllowed        bool
	RemoveRightsManagementProtection bool
}

type RightsTemplate struct {
	TemplateID  string
	Name        string
	Description string
}

type SMIMESigner struct {
	Certificate *x509.Certificate
	PrivateKey  crypto.PrivateKey
	// Intermediates are CAs to include in the SignedData chain so the
	// recipient can verify without consulting AIA URLs.
	Intermediates []*x509.Certificate
}

type SearchClient interface {
	GALSearch(ctx context.Context, query string, limit int) (*GALSearchResult, error)
	ResolveRecipients(ctx context.Context, recipients []string, opts ResolveOptions) ([]ResolveResponse, error)
	ValidateCert(ctx context.Context, certs, chain [][]byte, checkCRL bool) ([]CertValidation, error)
}

type SearchProp struct {
	Page byte
	Name string
}

type SendMailOptions struct {
	// MIME is the full RFC 5322 message bytes. Required.
	MIME []byte
	// SaveInSent toggles whether the server stores a copy in Sent Items.
	// Default true.
	SaveInSent bool
	// ClientID is an opaque idempotency key. If empty, a random 32-hex
	// value is generated; the same ClientID may be retried safely if a
	// previous attempt's status is unknown.
	ClientID string
	// SkipSaveInSent inverts SaveInSent without forcing the caller to
	// pass false explicitly (Go zero-value is false, which we want to
	// mean "save in sent" by default).
	SkipSaveInSent bool
}

type SettingsClient interface {
	GetOof(ctx context.Context) (*OofConfig, error)
	SetOof(ctx context.Context, cfg OofConfig) error
	SetDevicePassword(ctx context.Context, newPassword string) error
	GetUserInformation(ctx context.Context) (*UserInformation, error)
	SettingsDeviceInformation(ctx context.Context, info DeviceInformation) error
	GetRightsManagementTemplates(ctx context.Context) ([]RightsTemplate, error)
}

type StateStore interface {
	// PolicyKey returns the persisted policy key, or an empty string if the
	// account has not been provisioned yet. A nil error with an empty string
	// is the expected pre-provisioning state.
	PolicyKey(ctx context.Context) (string, error)
	// SetPolicyKey persists the provided key. An empty string clears the
	// stored key (used when re-provisioning is forced by a 449 response).
	SetPolicyKey(ctx context.Context, key string) error

	// SyncKey returns the most recently acknowledged SyncKey for folderID,
	// or "0" if no Sync has succeeded for that folder yet.
	SyncKey(ctx context.Context, folderID string) (string, error)
	// SetSyncKey persists the SyncKey returned by the server.
	SetSyncKey(ctx context.Context, folderID, key string) error
}

type StatusError struct {
	Command string // EAS command name ("FolderSync", "Provision", ...)
	Code    int
}

type SystemTime struct {
	Year         uint16
	Month        uint16
	DayOfWeek    uint16
	Day          uint16
	Hour         uint16
	Minute       uint16
	Second       uint16
	Milliseconds uint16
}

type TaskDraft = TaskItem

type TaskItem struct {
	ServerID string

	Subject       string
	Body          string
	Importance    int // 0=low, 1=normal, 2=high
	Sensitivity   int
	Complete      bool
	DateCompleted time.Time
	StartDate     time.Time
	UTCStartDate  time.Time
	DueDate       time.Time
	UTCDueDate    time.Time
	Reminder      time.Time
}

type TasksClient interface {
	SyncTasks(ctx context.Context, folderID string) (*TasksSyncResult, error)
	CreateTask(ctx context.Context, folderID string, draft TaskDraft) (string, error)
	UpdateTask(ctx context.Context, folderID, serverID string, draft TaskDraft) error
	CompleteTask(ctx context.Context, folderID, serverID string) error
	DeleteTask(ctx context.Context, folderID, serverID string) error
}

type TasksSyncResult struct {
	SyncKey       string
	MoreAvailable bool
	Added         []TaskItem
	Changed       []TaskItem
	Deleted       []string
}

type UserAccount struct {
	AccountID       string
	AccountName     string
	UserDisplayName string
	PrimarySMTP     string
	SendDisabled    bool
}

type UserInformation struct {
	PrimaryEmail string
	Accounts     []UserAccount
}