imap

type Address struct {
	// The personal name.
	PersonalName string
	// The SMTP at-domain-list (source route).
	AtDomainList string
	// The mailbox name.
	MailboxName string
	// The host name.
	HostName string
}

type BodyPartName struct {
	// The specifier of the requested part.
	Specifier string
	// The part path. Parts indexes start at 1.
	Path []int
	// If Specifier is HEADER, contains header fields that will/won't be returned,
	// depending of the value of NotFields.
	Fields []string
	// If set to true, Fields is a blacklist of fields instead of a whitelist.
	NotFields bool
}

type BodySectionName struct {
	*BodyPartName

	// If set to true, do not implicitely set the \Seen flag.
	Peek bool
	// The substring of the section requested. The first value is the position of
	// the first desired octet and the second value is the maximum number of
	// octets desired.
	Partial []int
	// contains filtered or unexported fields
}

type BodyStructure struct {

	// The MIME type.
	MimeType string
	// The MIME subtype.
	MimeSubType string
	// The MIME parameters.
	Params map[string]string

	// The Content-Id header.
	Id string
	// The Content-Description header.
	Description string
	// The Content-Encoding header.
	Encoding string
	// The Content-Length header.
	Size uint32

	// The children parts, if multipart.
	Parts []*BodyStructure
	// The envelope, if message/rfc822.
	Envelope *Envelope
	// The body structure, if message/rfc822.
	BodyStructure *BodyStructure
	// The number of lines, if text or message/rfc822.
	Lines uint32

	// True if the body structure contains extension data.
	Extended bool

	// The Content-Disposition header.
	Disposition string
	// The Content-Language header, if multipart.
	Language []string
	// The content URI, if multipart.
	Location []string

	// The MD5 checksum.
	Md5 string
}

type Command struct {
	// The command tag. It acts as a unique identifier for this command. If empty,
	// the command is untagged.
	Tag string
	// The command name.
	Name string
	// The command arguments.
	Arguments []interface{}
}

type Commander interface {
	Command() *Command
}

type Conn struct {
	net.Conn
	*Reader
	Writer
	// contains filtered or unexported fields
}

type ConnState int

type ConnUpgrader func(conn net.Conn) (net.Conn, error)

type ContinuationResp struct {
	// The info message sent with the continuation request.
	Info string
}

type Envelope struct {
	// The message date.
	Date time.Time
	// The message subject.
	Subject string
	// The From header addresses.
	From []*Address
	// The message senders.
	Sender []*Address
	// The Reply-To header addresses.
	ReplyTo []*Address
	// The To header addresses.
	To []*Address
	// The Cc header addresses.
	Cc []*Address
	// The Bcc header addresses.
	Bcc []*Address
	// The In-Reply-To header. Contains the parent Message-Id.
	InReplyTo string
	// The Message-Id header.
	MessageId string
}

type ErrBadSeqSet string

type FlagsOp string

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

type MailboxInfo struct {
	// The mailbox attributes.
	Attributes []string
	// The server's path separator.
	Delimiter string
	// The mailbox name.
	Name string
}

type MailboxStatus struct {
	// The mailbox name.
	Name string
	// True if the mailbox is open in read-only mode.
	ReadOnly bool
	// The mailbox items that are currently filled in.
	Items []string

	// The mailbox flags.
	Flags []string
	// The mailbox permanent flags.
	PermanentFlags []string

	// The number of messages in this mailbox.
	Messages uint32
	// The number of messages not seen since the last time the mailbox was opened.
	Recent uint32
	// The number of unread messages.
	Unseen uint32
	// The next UID.
	UidNext uint32
	// Together with a UID, it is a unique identifier for a message.
	// Must be greater than or equal to 1.
	UidValidity uint32
}

type Message struct {
	// The message sequence number. It must be greater than or equal to 1.
	SeqNum uint32
	// The message items that are currently filled in.
	Items []string
	// The message body sections.
	Body map[*BodySectionName]*Literal

	// The message envelope.
	Envelope *Envelope
	// The message body structure (either BODYSTRUCTURE or BODY).
	BodyStructure *BodyStructure
	// The message flags.
	Flags []string
	// The date the message was received by th server.
	InternalDate time.Time
	// The message size.
	Size uint32
	// The message unique identifier. It must be greater than or equal to 1.
	Uid uint32
}

type Parser interface {
	Parse(fields []interface{}) error
}

type Quoted string

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

type Resp struct {
	// The response tag. Can be either "" for untagged responses, "+" for continuation
	// requests or a previous command's tag.
	Tag string
	// The parsed response fields.
	Fields []interface{}
}

type RespHandler chan *RespHandling

type RespHandlerFrom interface {
	HandleFrom(hdlr RespHandler) error
}

type RespHandling struct {
	Resp    interface{}
	Accepts chan bool
}

type Responser interface {
	Response() *Resp
}

type SearchCriteria struct {
	SeqSet     *SeqSet
	Answered   bool
	Bcc        string
	Before     time.Time
	Body       string
	Cc         string
	Deleted    bool
	Draft      bool
	Flagged    bool
	From       string
	Header     [2]string
	Keyword    string
	Larger     uint32
	New        bool
	Not        *SearchCriteria
	Old        bool
	On         time.Time
	Or         [2]*SearchCriteria
	Recent     bool
	Seen       bool
	SentBefore time.Time
	SentOn     time.Time
	SentSince  time.Time
	Since      time.Time
	Smaller    uint32
	Subject    string
	Text       string
	To         string
	Uid        *SeqSet
	Unanswered bool
	Undeleted  bool
	Undraft    bool
	Unflagged  bool
	Unkeyword  string
	Unseen     bool
}

type Seq struct {
	Start, Stop uint32
}

type SeqSet struct {
	Set []Seq
}

type StatusResp struct {
	// The response tag. If empty, it defaults to *.
	Tag string

	// The status type.
	Type StatusRespType

	// The status code.
	// See https://www.iana.org/assignments/imap-response-codes/imap-response-codes.xhtml
	Code string

	// Arguments provided with the status code.
	Arguments []interface{}

	// The status info.
	Info string
}

type StatusRespType string

type StringReader interface {
	// ReadString reads until the first occurrence of delim in the input,
	// returning a string containing the data up to and including the delimiter.
	// See https://golang.org/pkg/bufio/#Reader.ReadString
	ReadString(delim byte) (line string, err error)
}

type Writer interface {
	io.Writer

	Flush() error
	// contains filtered or unexported methods
}

type WriterTo interface {
	WriteTo(w Writer) error
}