sig
module Base64 :
sig
module Decoder :
sig
type result =
[ `Clean of string | `Dirty of string | `Wrong_padding ]
val is_b64 : char -> bool
val decode : unit Parser.t -> unit Parser.t -> result Parser.t
val inline : unit -> result Parser.t
end
module Encoder :
sig
val w_inline_encode :
string ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.k0
val w_encode :
string ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.k0
end
module Input :
sig
type nonrec 'a t =
'a RingBuffer.Committed.t = {
mutable contents : 'a RingBuffer.t;
mutable mark : int option;
}
type mark = Weak of int | Uniq of int
val pp_with_mark : Format.formatter -> int * int * 'a t -> unit
val pp : Format.formatter -> 'a t -> unit
val copy : 'a t -> int -> 'a RingBuffer.t
val prepare : 'a t -> int -> 'a RingBuffer.t
val equal : mark -> mark -> bool
val mark : 'a t -> mark
val unmark : mark -> 'a t -> unit
val forget : mark -> 'a t -> unit
val write : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val write_string : 'a t -> string -> int -> int -> unit
val create_bytes : int -> Internal_buffer.st t
val create_bigstring : int -> Internal_buffer.bs t
val create_by : proof:'a Internal_buffer.t -> int -> 'a t
val size : 'a t -> int
val peek : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val read : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val read_space : 'a t -> ('a Internal_buffer.t * int * int) option
val write_space : 'a t -> ('a Internal_buffer.t * int * int) option
val transmit :
'a t -> ('a Internal_buffer.t -> int -> int -> int) -> int
val ravailable : 'a t -> int
val wavailable : 'a t -> int
val radvance : 'a t -> int -> unit
val wadvance : 'a t -> int -> unit
val get : 'a t -> char
val rollback : 'a t -> 'a Internal_buffer.t -> unit
val proof : 'a t -> 'a Internal_buffer.t
val savailable : 'a t -> int
end
type Parser.err += Wrong_padding
type 'a decoder
type decoding =
[ `Continue
| `Dirty of string
| `End of string
| `Error of Parser.err
| `String of string ]
val decoder : unit Parser.t * unit Parser.t -> 'a Input.t -> 'a decoder
val decoder_src : 'a decoder -> 'a Input.t
val decode : 'a decoder -> decoding
val src : 'a decoder -> string -> int -> int -> unit
end
module QuotedPrintable :
sig
module Decoder :
sig
val is_hex : char -> bool
val hex : char Parser.t
val decode : unit Parser.t -> unit Parser.t -> string Parser.t
val inline : unit -> string Parser.t
end
module Encoder :
sig
val w_inline_encode :
string ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.k0
val w_encode :
string ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.k0
end
module Input :
sig
type nonrec 'a t =
'a RingBuffer.Committed.t = {
mutable contents : 'a RingBuffer.t;
mutable mark : int option;
}
type mark = Weak of int | Uniq of int
val pp_with_mark : Format.formatter -> int * int * 'a t -> unit
val pp : Format.formatter -> 'a t -> unit
val copy : 'a t -> int -> 'a RingBuffer.t
val prepare : 'a t -> int -> 'a RingBuffer.t
val equal : mark -> mark -> bool
val mark : 'a t -> mark
val unmark : mark -> 'a t -> unit
val forget : mark -> 'a t -> unit
val write : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val write_string : 'a t -> string -> int -> int -> unit
val create_bytes : int -> Internal_buffer.st t
val create_bigstring : int -> Internal_buffer.bs t
val create_by : proof:'a Internal_buffer.t -> int -> 'a t
val size : 'a t -> int
val peek : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val read : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val read_space : 'a t -> ('a Internal_buffer.t * int * int) option
val write_space : 'a t -> ('a Internal_buffer.t * int * int) option
val transmit :
'a t -> ('a Internal_buffer.t -> int -> int -> int) -> int
val ravailable : 'a t -> int
val wavailable : 'a t -> int
val radvance : 'a t -> int -> unit
val wadvance : 'a t -> int -> unit
val get : 'a t -> char
val rollback : 'a t -> 'a Internal_buffer.t -> unit
val proof : 'a t -> 'a Internal_buffer.t
val savailable : 'a t -> int
end
type 'a decoder
type decoding =
[ `Continue
| `Dirty of char
| `End of string
| `Error of Parser.err
| `String of string ]
val decoder : unit Parser.t * unit Parser.t -> 'a Input.t -> 'a decoder
val decoder_src : 'a decoder -> 'a Input.t
val decode : 'a decoder -> decoding
val src : 'a decoder -> string -> int -> int -> unit
end
module Date :
sig
type day = Rfc5322.day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
type month =
Rfc5322.month =
Jan
| Feb
| Mar
| Apr
| May
| Jun
| Jul
| Aug
| Sep
| Oct
| Nov
| Dec
type zone =
Rfc5322.zone =
UT
| GMT
| EST
| EDT
| CST
| CDT
| MST
| MDT
| PST
| PDT
| Military_zone of char
| TZ of int
type date =
Rfc5322.date = {
day : day option;
date : int * month * int;
time : int * int * int option;
zone : zone;
}
val pp_zone : Format.formatter -> zone -> unit
val pp_month : Format.formatter -> month -> unit
val pp_day : Format.formatter -> day -> unit
val pp : Format.formatter -> date -> unit
module Encoder :
sig
val w_day :
(day,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_time :
(int * int * int option,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_zone :
(zone,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_date :
(date,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
end
module Decoder :
sig
val p_hour : int MrMime_parser.t
val p_minute : int MrMime_parser.t
val p_second : int MrMime_parser.t
val p_year : int MrMime_parser.t
val p_day : int MrMime_parser.t
val p_month : month MrMime_parser.t
val p_day_of_week : day MrMime_parser.t
val p_zone : zone MrMime_parser.t
val p_time : ((int * int * int option) * zone) MrMime_parser.t
val p_date : (int * month * int) MrMime_parser.t
val p_date_time : date MrMime_parser.t
end
val to_string : date -> string
val of_string : ?chunk:int -> string -> date option
val of_string_raw :
?chunk:int -> string -> int -> int -> (date * int) option
val equal : date -> date -> bool
end
module Address :
sig
type word = [ `Atom of string | `String of string ]
type local = word list
type raw =
Rfc2047.raw =
QuotedPrintable of string
| Base64 of MrMime_base64.Decoder.result
type literal_domain = Rfc5321.literal_domain = ..
type literal_domain += IPv4 of Ipaddr.V4.t
type literal_domain += IPv6 of Ipaddr.V6.t
type phrase = [ `Dot | `Encoded of string * raw | `Word of word ] list
type domain = [ `Domain of string list | `Literal of literal_domain ]
type mailbox =
Rfc5322.mailbox = {
name : phrase option;
local : local;
domain : domain * domain list;
}
type group = Rfc5322.group = { name : phrase; mailbox : mailbox list; }
type address = [ `Group of group | `Mailbox of mailbox ]
val pp_word : Format.formatter -> word -> unit
val pp_domain : Format.formatter -> domain -> unit
val pp_phrase : Format.formatter -> phrase -> unit
val pp_local : Format.formatter -> local -> unit
val pp_mailbox' :
Format.formatter -> local * (domain * domain list) -> unit
val pp_mailbox : Format.formatter -> mailbox -> unit
val pp_group : Format.formatter -> group -> unit
val pp : Format.formatter -> address -> unit
module Encoder :
sig
val w_word :
(word,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_domain :
(domain,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_safe_string :
(string,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_raw :
(raw,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_phrase :
(phrase,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_local :
(local,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_mailbox' :
(local * (domain * domain list),
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_mailbox :
(mailbox,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_group :
(group,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_address :
(address,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_addresses :
(address list,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
end
module Decoder :
sig
val p_address : address MrMime_parser.t
val p_addresses : address list MrMime_parser.t
val p_local : local MrMime_parser.t
val p_domain : domain MrMime_parser.t
end
val to_string : address -> string
val of_string : ?chunk:int -> string -> address option
val of_string_raw :
?chunk:int -> string -> int -> int -> (address * int) option
val equal : address -> address -> bool
module List :
sig
val pp : Format.formatter -> address list -> unit
val to_string : address list -> string
val of_string : ?chunk:int -> string -> address list option
val of_string_raw :
?chunk:int -> string -> int -> int -> (address list * int) option
val equal : address list -> address list -> bool
end
module Make :
sig
type z = Z
type 'a s = S
type 'a word
type ('data, 'peano) llist
val word : string -> [ `Atom | `String ] word
val atom : string -> [> `Atom ] word
val e : ([> `Atom ] word, z) llist
val ( & ) : 'a word -> ('a word, 'x) llist -> ('a word, 'x s) llist
val ( @ ) :
([ `Atom | `String ] word, 'a s) llist ->
([ `Atom ] word, 'b s) llist -> mailbox
end
module Extension :
sig
val add_literal_domain :
string -> literal_domain MrMime_parser.t -> unit
end
end
module Resent :
sig
type field = Rfc5322.resent
type resent = {
date : MrMime_date.date option;
from : MrMime_address.mailbox list;
sender : MrMime_address.mailbox option;
to' : MrMime_address.address list;
cc : MrMime_address.address list;
bcc : MrMime_address.address list;
msg_id : MrMime_msgID.msg_id option;
reply_to : MrMime_address.address list;
}
val default : resent
module Date :
sig
type day = Rfc5322.day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
type month =
Rfc5322.month =
Jan
| Feb
| Mar
| Apr
| May
| Jun
| Jul
| Aug
| Sep
| Oct
| Nov
| Dec
type zone =
Rfc5322.zone =
UT
| GMT
| EST
| EDT
| CST
| CDT
| MST
| MDT
| PST
| PDT
| Military_zone of char
| TZ of int
type date =
Rfc5322.date = {
day : day option;
date : int * month * int;
time : int * int * int option;
zone : zone;
}
val pp_zone : Format.formatter -> zone -> unit
val pp_month : Format.formatter -> month -> unit
val pp_day : Format.formatter -> day -> unit
val pp : Format.formatter -> date -> unit
module Encoder :
sig
val w_day :
(MrMime_date.day,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_time :
(int * int * int option,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_zone :
(MrMime_date.zone,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_date :
(MrMime_date.date,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
end
module Decoder :
sig
val p_hour : int MrMime_parser.t
val p_minute : int MrMime_parser.t
val p_second : int MrMime_parser.t
val p_year : int MrMime_parser.t
val p_day : int MrMime_parser.t
val p_month : MrMime_date.month MrMime_parser.t
val p_day_of_week : MrMime_date.day MrMime_parser.t
val p_zone : MrMime_date.zone MrMime_parser.t
val p_time :
((int * int * int option) * MrMime_date.zone) MrMime_parser.t
val p_date : (int * MrMime_date.month * int) MrMime_parser.t
val p_date_time : MrMime_date.date MrMime_parser.t
end
val to_string : date -> string
val of_string : ?chunk:int -> string -> date option
val of_string_raw :
?chunk:int -> string -> int -> int -> (date * int) option
val equal : date -> date -> bool
end
module Address :
sig
type word = [ `Atom of string | `String of string ]
type local = word list
type raw =
Rfc2047.raw =
QuotedPrintable of string
| Base64 of MrMime_base64.Decoder.result
type literal_domain = Rfc5321.literal_domain = ..
type literal_domain += IPv4 of Ipaddr.V4.t
type literal_domain += IPv6 of Ipaddr.V6.t
type phrase =
[ `Dot | `Encoded of string * raw | `Word of word ] list
type domain =
[ `Domain of string list | `Literal of literal_domain ]
type mailbox =
Rfc5322.mailbox = {
name : phrase option;
local : local;
domain : domain * domain list;
}
type group =
Rfc5322.group = {
name : phrase;
mailbox : mailbox list;
}
type address = [ `Group of group | `Mailbox of mailbox ]
val pp_word : Format.formatter -> word -> unit
val pp_domain : Format.formatter -> domain -> unit
val pp_phrase : Format.formatter -> phrase -> unit
val pp_local : Format.formatter -> local -> unit
val pp_mailbox' :
Format.formatter -> local * (domain * domain list) -> unit
val pp_mailbox : Format.formatter -> mailbox -> unit
val pp_group : Format.formatter -> group -> unit
val pp : Format.formatter -> address -> unit
module Encoder :
sig
val w_word :
(MrMime_address.word,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_domain :
(MrMime_address.domain,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_safe_string :
(string,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_raw :
(MrMime_address.raw,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_phrase :
(MrMime_address.phrase,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_local :
(MrMime_address.local,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_mailbox' :
(MrMime_address.local *
(MrMime_address.domain * MrMime_address.domain list),
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_mailbox :
(MrMime_address.mailbox,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_group :
(MrMime_address.group,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_address :
(MrMime_address.address,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_addresses :
(MrMime_address.address list,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
end
module Decoder :
sig
val p_address : MrMime_address.address MrMime_parser.t
val p_addresses : MrMime_address.address list MrMime_parser.t
val p_local : MrMime_address.local MrMime_parser.t
val p_domain : MrMime_address.domain MrMime_parser.t
end
val to_string : address -> string
val of_string : ?chunk:int -> string -> address option
val of_string_raw :
?chunk:int -> string -> int -> int -> (address * int) option
val equal : address -> address -> bool
module List :
sig
val pp :
Format.formatter -> MrMime_address.address list -> unit
val to_string : MrMime_address.address list -> string
val of_string :
?chunk:int -> string -> MrMime_address.address list option
val of_string_raw :
?chunk:int ->
string ->
int -> int -> (MrMime_address.address list * int) option
val equal :
MrMime_address.address list ->
MrMime_address.address list -> bool
end
module Make :
sig
type z = MrMime_address.Make.z = Z
type 'a s = 'a MrMime_address.Make.s = S
type 'a word = 'a MrMime_address.Make.word
type ('data, 'peano) llist =
('data, 'peano) MrMime_address.Make.llist
val word : string -> [ `Atom | `String ] word
val atom : string -> [> `Atom ] word
val e : ([> `Atom ] word, z) llist
val ( & ) :
'a word -> ('a word, 'x) llist -> ('a word, 'x s) llist
val ( @ ) :
([ `Atom | `String ] word, 'a s) llist ->
([ `Atom ] word, 'b s) llist -> MrMime_address.mailbox
end
module Extension :
sig
val add_literal_domain :
string ->
MrMime_address.literal_domain MrMime_parser.t -> unit
end
end
module MsgID :
sig
type word = [ `Atom of string | `String of string ]
type local = word list
type domain = [ `Domain of string list | `Literal of string ]
type msg_id = local * domain
val pp_local : Format.formatter -> local -> unit
val pp_domain : Format.formatter -> domain -> unit
val pp : Format.formatter -> msg_id -> unit
module Encoder :
sig
val w_left :
(MrMime_msgID.local,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_right :
(MrMime_msgID.domain,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_msg_id :
(MrMime_msgID.msg_id,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
end
module Decoder :
sig val p_msg_id : MrMime_msgID.msg_id MrMime_parser.t end
val of_string : ?chunk:int -> string -> msg_id option
val of_string_raw :
?chunk:int -> string -> int -> int -> (msg_id * int) option
end
val pp : Format.formatter -> 'a -> unit
module Encoder :
sig
val w_lst :
(('a -> 'b) -> 'a -> 'b) ->
('c -> ('a -> 'b) -> 'a -> 'b) ->
'c list -> ('a -> 'b) -> 'a -> 'b
val w_crlf :
(Encoder.t ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial) ->
Encoder.t -> 'a Encoder.partial
val w_field :
[< `ResentBcc of MrMime_address.address list
| `ResentCc of MrMime_address.address list
| `ResentDate of MrMime_date.date
| `ResentFrom of MrMime_address.mailbox list
| `ResentMessageID of MrMime_msgID.msg_id
| `ResentReplyTo of MrMime_address.address list
| `ResentSender of MrMime_address.mailbox
| `ResentTo of MrMime_address.address list ] ->
(Encoder.t ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.partial Encoder.partial Encoder.partial) ->
Encoder.t ->
'a Encoder.partial Encoder.partial Encoder.partial
Encoder.partial
val w_resent :
resent ->
(Encoder.t ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.partial Encoder.partial Encoder.partial) ->
Encoder.t ->
'a Encoder.partial Encoder.partial Encoder.partial
Encoder.partial
end
val decoder :
([> field ] as 'a) list -> (resent list * 'a list) Parser.t
val equal : 'a -> 'a -> bool
end
module Trace :
sig
type local = Rfc822.local
type domain = Rfc5322.domain
type word = Rfc822.word
type field = Rfc5322.trace
type received =
[ `Addr of local * (domain * domain list)
| `Domain of domain
| `Word of word ]
type trace = {
trace : (local * (domain * domain list)) option;
received : (received list * MrMime_date.date option) list;
}
module Address :
sig
type word = [ `Atom of string | `String of string ]
type local = word list
type raw =
Rfc2047.raw =
QuotedPrintable of string
| Base64 of MrMime_base64.Decoder.result
type literal_domain = Rfc5321.literal_domain = ..
type literal_domain += IPv4 of Ipaddr.V4.t
type literal_domain += IPv6 of Ipaddr.V6.t
type phrase =
[ `Dot | `Encoded of string * raw | `Word of word ] list
type domain =
[ `Domain of string list | `Literal of literal_domain ]
type mailbox =
Rfc5322.mailbox = {
name : phrase option;
local : local;
domain : domain * domain list;
}
type group =
Rfc5322.group = {
name : phrase;
mailbox : mailbox list;
}
type address = [ `Group of group | `Mailbox of mailbox ]
val pp_word : Format.formatter -> word -> unit
val pp_domain : Format.formatter -> domain -> unit
val pp_phrase : Format.formatter -> phrase -> unit
val pp_local : Format.formatter -> local -> unit
val pp_mailbox' :
Format.formatter -> local * (domain * domain list) -> unit
val pp_mailbox : Format.formatter -> mailbox -> unit
val pp_group : Format.formatter -> group -> unit
val pp : Format.formatter -> address -> unit
module Encoder :
sig
val w_word :
(MrMime_address.word,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_domain :
(MrMime_address.domain,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_safe_string :
(string,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_raw :
(MrMime_address.raw,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_phrase :
(MrMime_address.phrase,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_local :
(MrMime_address.local,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_mailbox' :
(MrMime_address.local *
(MrMime_address.domain * MrMime_address.domain list),
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_mailbox :
(MrMime_address.mailbox,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_group :
(MrMime_address.group,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_address :
(MrMime_address.address,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_addresses :
(MrMime_address.address list,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
end
module Decoder :
sig
val p_address : MrMime_address.address MrMime_parser.t
val p_addresses : MrMime_address.address list MrMime_parser.t
val p_local : MrMime_address.local MrMime_parser.t
val p_domain : MrMime_address.domain MrMime_parser.t
end
val to_string : address -> string
val of_string : ?chunk:int -> string -> address option
val of_string_raw :
?chunk:int -> string -> int -> int -> (address * int) option
val equal : address -> address -> bool
module List :
sig
val pp :
Format.formatter -> MrMime_address.address list -> unit
val to_string : MrMime_address.address list -> string
val of_string :
?chunk:int -> string -> MrMime_address.address list option
val of_string_raw :
?chunk:int ->
string ->
int -> int -> (MrMime_address.address list * int) option
val equal :
MrMime_address.address list ->
MrMime_address.address list -> bool
end
module Make :
sig
type z = MrMime_address.Make.z = Z
type 'a s = 'a MrMime_address.Make.s = S
type 'a word = 'a MrMime_address.Make.word
type ('data, 'peano) llist =
('data, 'peano) MrMime_address.Make.llist
val word : string -> [ `Atom | `String ] word
val atom : string -> [> `Atom ] word
val e : ([> `Atom ] word, z) llist
val ( & ) :
'a word -> ('a word, 'x) llist -> ('a word, 'x s) llist
val ( @ ) :
([ `Atom | `String ] word, 'a s) llist ->
([ `Atom ] word, 'b s) llist -> MrMime_address.mailbox
end
module Extension :
sig
val add_literal_domain :
string ->
MrMime_address.literal_domain MrMime_parser.t -> unit
end
end
module Date :
sig
type day = Rfc5322.day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
type month =
Rfc5322.month =
Jan
| Feb
| Mar
| Apr
| May
| Jun
| Jul
| Aug
| Sep
| Oct
| Nov
| Dec
type zone =
Rfc5322.zone =
UT
| GMT
| EST
| EDT
| CST
| CDT
| MST
| MDT
| PST
| PDT
| Military_zone of char
| TZ of int
type date =
Rfc5322.date = {
day : day option;
date : int * month * int;
time : int * int * int option;
zone : zone;
}
val pp_zone : Format.formatter -> zone -> unit
val pp_month : Format.formatter -> month -> unit
val pp_day : Format.formatter -> day -> unit
val pp : Format.formatter -> date -> unit
module Encoder :
sig
val w_day :
(MrMime_date.day,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_time :
(int * int * int option,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_zone :
(MrMime_date.zone,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_date :
(MrMime_date.date,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
end
module Decoder :
sig
val p_hour : int MrMime_parser.t
val p_minute : int MrMime_parser.t
val p_second : int MrMime_parser.t
val p_year : int MrMime_parser.t
val p_day : int MrMime_parser.t
val p_month : MrMime_date.month MrMime_parser.t
val p_day_of_week : MrMime_date.day MrMime_parser.t
val p_zone : MrMime_date.zone MrMime_parser.t
val p_time :
((int * int * int option) * MrMime_date.zone) MrMime_parser.t
val p_date : (int * MrMime_date.month * int) MrMime_parser.t
val p_date_time : MrMime_date.date MrMime_parser.t
end
val to_string : date -> string
val of_string : ?chunk:int -> string -> date option
val of_string_raw :
?chunk:int -> string -> int -> int -> (date * int) option
val equal : date -> date -> bool
end
val pp_lst :
sep:(Format.formatter -> unit -> unit) ->
(Format.formatter -> 'a -> unit) ->
Format.formatter -> 'a list -> unit
val pp_path :
Format.formatter ->
Address.local * (Address.domain * Address.domain list) -> unit
val pp_received :
Format.formatter ->
[< `Addr of Address.local * (Address.domain * Address.domain list)
| `Domain of Address.domain
| `Word of Address.word ]
list * Date.date option -> unit
val pp : Format.formatter -> trace -> unit
module Encoder :
sig
val w_crlf :
(Encoder.t ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial) ->
Encoder.t -> 'a Encoder.partial
val w_lst :
(('a -> 'b) -> 'a -> 'b) ->
('c -> ('a -> 'b) -> 'a -> 'b) ->
'c list -> ('a -> 'b) -> 'a -> 'b
val w_field' :
[< `Received of
[< `Addr of
MrMime_address.local *
(MrMime_address.domain * MrMime_address.domain list)
| `Domain of MrMime_address.domain
| `Word of MrMime_address.word ]
list * MrMime_date.date option
| `ReturnPath of
(MrMime_address.local *
(MrMime_address.domain * MrMime_address.domain list))
option ] ->
(Encoder.t ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.partial Encoder.partial Encoder.partial
Encoder.partial Encoder.partial) ->
Encoder.t ->
'a Encoder.partial Encoder.partial Encoder.partial
Encoder.partial Encoder.partial Encoder.partial
val w_field :
[< `Trace of
(MrMime_address.local *
(MrMime_address.domain * MrMime_address.domain list))
option *
([< `Addr of
MrMime_address.local *
(MrMime_address.domain * MrMime_address.domain list)
| `Domain of MrMime_address.domain
| `Word of MrMime_address.word ]
list * MrMime_date.date option)
list ] ->
(Encoder.t ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.partial Encoder.partial Encoder.partial
Encoder.partial Encoder.partial) ->
Encoder.t ->
'a Encoder.partial Encoder.partial Encoder.partial
Encoder.partial Encoder.partial Encoder.partial
val w_trace :
trace ->
(Encoder.t ->
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial Encoder.partial Encoder.partial Encoder.partial
Encoder.partial Encoder.partial) ->
Encoder.t ->
'a Encoder.partial Encoder.partial Encoder.partial
Encoder.partial Encoder.partial Encoder.partial
end
val decoder :
([> field ] as 'a) list -> (trace list * 'a list) Parser.t
val equal : 'a -> 'a -> bool
end
module Header :
sig
type raw =
Rfc2047.raw =
QuotedPrintable of string
| Base64 of MrMime_base64.Decoder.result
type unstructured =
[ `CR of int
| `CRLF
| `Encoded of string * raw
| `LF of int
| `Text of string
| `WSP ] list
type phrase_or_msg_id =
[ `MsgID of MrMime_msgID.msg_id
| `Phrase of
[ `Dot
| `Encoded of string * raw
| `Word of [ `Atom of string | `String of string ] ] list ]
type field = Rfc5322.field
module Map :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
end
type header = {
date : MrMime_date.date option;
from : MrMime_address.mailbox list;
sender : MrMime_address.mailbox option;
reply_to : MrMime_address.address list;
to' : MrMime_address.address list;
cc : MrMime_address.address list;
bcc : MrMime_address.address list;
subject : unstructured option;
msg_id : MrMime_msgID.msg_id option;
in_reply_to : phrase_or_msg_id list;
references : phrase_or_msg_id list;
comments : unstructured list;
keywords : MrMime_address.phrase list list;
resents : MrMime_resent.resent list;
traces : MrMime_trace.trace list;
fields : unstructured list Map.t;
unsafe : unstructured list Map.t;
skip : string list;
}
val pp_raw : Format.formatter -> raw -> unit
val pp_unstructured : Format.formatter -> unstructured -> unit
val pp_phrase_or_msg_id : Format.formatter -> phrase_or_msg_id -> unit
val pp_field : Format.formatter -> field -> unit
val pp : Format.formatter -> header -> unit
module Encoder :
sig
val w_unstructured :
(unstructured,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_field :
([ `Bcc of Rfc5322.address list
| `Cc of Rfc5322.address list
| `Comments of Rfc5322.unstructured
| `Date of Rfc5322.date
| `Field of string * Rfc5322.unstructured
| `From of Rfc5322.mailbox list
| `InReplyTo of Rfc5322.phrase_or_msg_id list
| `Keywords of Rfc5322.phrase list
| `MessageID of Rfc822.msg_id
| `References of Rfc5322.phrase_or_msg_id list
| `ReplyTo of Rfc5322.address list
| `Sender of Rfc5322.mailbox
| `Skip of string
| `Subject of Rfc5322.unstructured
| `To of Rfc5322.address list
| `Unsafe of string * Rfc5322.unstructured ],
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
val w_header :
(header,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
end
module Decoder :
sig
val header :
([> field ] as 'a) list -> (header * 'a list) MrMime_parser.t
end
val to_string : header -> string
val of_string :
?chunk:int -> string -> (header * [> field ] list) option
val of_string_raw :
?chunk:int ->
string -> int -> int -> ((header * [> field ] list) * int) option
val equal : header -> header -> bool
end
module Content :
sig
module Map :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
end
type raw =
Rfc2047.raw =
QuotedPrintable of string
| Base64 of MrMime_base64.Decoder.result
type unstructured =
[ `CR of int
| `CRLF
| `Encoded of string * raw
| `LF of int
| `Text of string
| `WSP ] list
type field =
[ `Content of string * Rfc5322.unstructured
| `ContentDescription of Rfc5322.unstructured
| `ContentEncoding of Rfc2045.mechanism
| `ContentID of Rfc822.msg_id
| `ContentType of Rfc2045.content
| `MimeVersion of Rfc2045.version
| `Skip of string ]
type t = {
ty : MrMime_contentType.content;
encoding : MrMime_contentEncoding.mechanism;
version : MrMime_mimeVersion.version;
id : MrMime_msgID.msg_id option;
description : unstructured option;
content : unstructured list Map.t;
unsafe : unstructured list Map.t;
skip : string list;
}
val pp_raw : Format.formatter -> Rfc2047.raw -> unit
val pp_unstructured : Format.formatter -> unstructured -> unit
val pp_field : Format.formatter -> field -> unit
val pp : Format.formatter -> t -> unit
val default : t
module Encoder :
sig
val w_field :
(Rfc2045.field,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
val w_field_version :
(Rfc2045.field_version,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
val w_unsafe :
(Rfc2045.unsafe,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
val w_skip :
(Rfc2045.skip,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
val w_message :
(t,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
val w_part :
(t,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
end
module Decoder :
sig
val message :
([> `Content of string * Rfc5322.unstructured
| `ContentDescription of Rfc5322.unstructured
| `ContentEncoding of Rfc2045.mechanism
| `ContentID of Rfc822.msg_id
| `ContentType of Rfc2045.content
| `MimeVersion of Rfc2045.version ]
as 'a)
list -> (t * 'a list) MrMime_parser.t
val part :
([> `Content of string * Rfc5322.unstructured
| `ContentDescription of Rfc5322.unstructured
| `ContentEncoding of Rfc2045.mechanism
| `ContentID of Rfc822.msg_id
| `ContentType of Rfc2045.content
| `Skip of string
| `Unsafe of string * Rfc5322.unstructured ]
as 'a)
list -> (t * 'a list) MrMime_parser.t
end
end
module ContentType :
sig
type ty =
[ `Application
| `Audio
| `Ietf_token of string
| `Image
| `Message
| `Multipart
| `Text
| `Video
| `X_token of string ]
type subty =
[ `Iana_token of string
| `Ietf_token of string
| `X_token of string ]
type value = [ `String of string | `Token of string ]
type field = [ `ContentType of Rfc2045.content ]
type content =
Rfc2045.content = {
ty : ty;
subty : subty;
parameters : (string * value) list;
}
val pp_ty : Format.formatter -> ty -> unit
val pp_subty : Format.formatter -> subty -> unit
val pp_value : Format.formatter -> value -> unit
val pp_parameter : Format.formatter -> string * value -> unit
val pp : Format.formatter -> content -> unit
val default : content
module Encoder :
sig
val w_type :
(ty,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_subtype :
(subty,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_value :
(value,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_parameter :
(string * value,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_content :
(content,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_field :
(field,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
end
module Decoder : sig val p_content : content MrMime_parser.t end
val of_string : ?chunk:int -> string -> content option
val of_string_raw :
?chunk:int -> string -> int -> int -> (content * int) option
end
module ContentEncoding :
sig
type mechanism =
[ `Base64
| `Binary
| `Bit7
| `Bit8
| `Ietf_token of string
| `QuotedPrintable
| `X_token of string ]
type field = [ `ContentEncoding of mechanism ]
val pp : Format.formatter -> mechanism -> unit
val default : mechanism
module Encoder :
sig
val w_encoding :
(mechanism,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
val w_field :
(field,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
end
module Decoder : sig val p_encoding : mechanism MrMime_parser.t end
val of_string : ?chunk:int -> string -> mechanism option
val of_string_raw :
?chunk:int -> string -> int -> int -> (mechanism * int) option
end
module MimeVersion :
sig
type version = int * int
type field = [ `MimeVersion of version ]
val pp : Format.formatter -> version -> unit
val default : version
module Encoder :
sig
val w_version :
(version,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_field :
(field,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Encoder.k1
end
module Decoder : sig val p_version : version MrMime_parser.t end
val of_string : ?chunk:int -> string -> version option
val of_string_raw :
?chunk:int -> string -> int -> int -> (version * int) option
end
module MsgID :
sig
type word = [ `Atom of string | `String of string ]
type local = word list
type domain = [ `Domain of string list | `Literal of string ]
type msg_id = local * domain
val pp_local : Format.formatter -> local -> unit
val pp_domain : Format.formatter -> domain -> unit
val pp : Format.formatter -> msg_id -> unit
module Encoder :
sig
val w_left :
(local,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_right :
(domain,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
val w_msg_id :
(msg_id,
([> `Partial of Bytes.t * int * int * (int -> 'a) ] as 'a)
Encoder.partial)
Wrap.k1
end
module Decoder : sig val p_msg_id : msg_id MrMime_parser.t end
val of_string : ?chunk:int -> string -> msg_id option
val of_string_raw :
?chunk:int -> string -> int -> int -> (msg_id * int) option
end
module Message :
sig
type field_message = Top.field_message
type field_part = Top.field_part
type ('a, 'b) message =
('a, 'b) Top.message =
Discrete of MrMime_content.t * field_message list * 'a
| Extension of MrMime_content.t * field_message list * 'b
| Multipart of MrMime_content.t * field_message list *
(MrMime_content.t * field_part list * ('a, 'b) part option) list
| Message of MrMime_content.t * field_message list *
MrMime_header.header * ('a, 'b) message
and ('a, 'b) part =
('a, 'b) Top.part =
PDiscrete of 'a
| PExtension of 'b
| PMultipart of
(MrMime_content.t * field_part list * ('a, 'b) part option) list
| PMessage of MrMime_header.header * ('a, 'b) message
type encoding = ..
type encoding += Base64 of MrMime_base64.Decoder.result
type encoding += QuotedPrintable of string
type encoding += Raw of string
type content = ..
type content += Unit
module Decoder :
sig
val p_message :
(MrMime_header.header * (encoding, content) message)
MrMime_parser.t
val p_header :
(MrMime_header.header * MrMime_content.t *
[ `Bcc of Rfc5322.address list
| `Cc of Rfc5322.address list
| `Comments of Rfc5322.unstructured
| `Content of string * Rfc5322.unstructured
| `ContentDescription of Rfc5322.unstructured
| `ContentEncoding of Rfc2045.mechanism
| `ContentID of Rfc822.msg_id
| `ContentType of Rfc2045.content
| `Date of Rfc5322.date
| `Field of string * Rfc5322.unstructured
| `From of Rfc5322.mailbox list
| `InReplyTo of Rfc5322.phrase_or_msg_id list
| `Keywords of Rfc5322.phrase list
| `MessageID of Rfc822.msg_id
| `MimeVersion of Rfc2045.version
| `References of Rfc5322.phrase_or_msg_id list
| `ReplyTo of Rfc5322.address list
| `ResentBcc of Rfc5322.address list
| `ResentCc of Rfc5322.address list
| `ResentDate of Rfc5322.date
| `ResentFrom of Rfc5322.mailbox list
| `ResentMessageID of Rfc822.msg_id
| `ResentReplyTo of Rfc5322.address list
| `ResentSender of Rfc5322.mailbox
| `ResentTo of Rfc5322.address list
| `Sender of Rfc5322.mailbox
| `Skip of string
| `Subject of Rfc5322.unstructured
| `To of Rfc5322.address list
| `Trace of
(Rfc822.local * (Rfc5322.domain * Rfc5322.domain list))
option *
([ `Addr of
Rfc822.local * (Rfc5322.domain * Rfc5322.domain list)
| `Domain of Rfc5322.domain
| `Word of Rfc822.word ] list * Rfc5322.date option)
list
| `Unsafe of string * Rfc5322.unstructured ] list)
MrMime_parser.t
val p_first_part :
MrMime_content.t ->
(MrMime_content.t *
[ `Bcc of Rfc5322.address list
| `Cc of Rfc5322.address list
| `Comments of Rfc5322.unstructured
| `Content of string * Rfc5322.unstructured
| `ContentDescription of Rfc5322.unstructured
| `ContentEncoding of Rfc2045.mechanism
| `ContentID of Rfc822.msg_id
| `ContentType of Rfc2045.content
| `Date of Rfc5322.date
| `Field of string * Rfc5322.unstructured
| `From of Rfc5322.mailbox list
| `InReplyTo of Rfc5322.phrase_or_msg_id list
| `Keywords of Rfc5322.phrase list
| `MessageID of Rfc822.msg_id
| `MimeVersion of Rfc2045.version
| `References of Rfc5322.phrase_or_msg_id list
| `ReplyTo of Rfc5322.address list
| `ResentBcc of Rfc5322.address list
| `ResentCc of Rfc5322.address list
| `ResentDate of Rfc5322.date
| `ResentFrom of Rfc5322.mailbox list
| `ResentMessageID of Rfc822.msg_id
| `ResentReplyTo of Rfc5322.address list
| `ResentSender of Rfc5322.mailbox
| `ResentTo of Rfc5322.address list
| `Sender of Rfc5322.mailbox
| `Skip of string
| `Subject of Rfc5322.unstructured
| `To of Rfc5322.address list
| `Trace of
(Rfc822.local * (Rfc5322.domain * Rfc5322.domain list))
option *
([ `Addr of
Rfc822.local * (Rfc5322.domain * Rfc5322.domain list)
| `Domain of Rfc5322.domain
| `Word of Rfc822.word ] list * Rfc5322.date option)
list
| `Unsafe of string * Rfc5322.unstructured ] list)
MrMime_parser.t
val p_next_part :
MrMime_content.t ->
(MrMime_content.t *
[ `Bcc of Rfc5322.address list
| `Cc of Rfc5322.address list
| `Comments of Rfc5322.unstructured
| `Content of string * Rfc5322.unstructured
| `ContentDescription of Rfc5322.unstructured
| `ContentEncoding of Rfc2045.mechanism
| `ContentID of Rfc822.msg_id
| `ContentType of Rfc2045.content
| `Date of Rfc5322.date
| `Field of string * Rfc5322.unstructured
| `From of Rfc5322.mailbox list
| `InReplyTo of Rfc5322.phrase_or_msg_id list
| `Keywords of Rfc5322.phrase list
| `MessageID of Rfc822.msg_id
| `MimeVersion of Rfc2045.version
| `References of Rfc5322.phrase_or_msg_id list
| `ReplyTo of Rfc5322.address list
| `ResentBcc of Rfc5322.address list
| `ResentCc of Rfc5322.address list
| `ResentDate of Rfc5322.date
| `ResentFrom of Rfc5322.mailbox list
| `ResentMessageID of Rfc822.msg_id
| `ResentReplyTo of Rfc5322.address list
| `ResentSender of Rfc5322.mailbox
| `ResentTo of Rfc5322.address list
| `Sender of Rfc5322.mailbox
| `Skip of string
| `Subject of Rfc5322.unstructured
| `To of Rfc5322.address list
| `Trace of
(Rfc822.local * (Rfc5322.domain * Rfc5322.domain list))
option *
([ `Addr of
Rfc822.local * (Rfc5322.domain * Rfc5322.domain list)
| `Domain of Rfc5322.domain
| `Word of Rfc822.word ] list * Rfc5322.date option)
list
| `Unsafe of string * Rfc5322.unstructured ] list)
MrMime_parser.t
val p_bound_of_content :
MrMime_content.t -> unit MrMime_parser.t * unit MrMime_parser.t
val p_store_part :
MrMime_content.t ->
MrMime_content.t ->
[ `End of encoding option | `Next of encoding option ]
MrMime_parser.t
val p_discard_part :
MrMime_content.t -> [ `End | `Next ] MrMime_parser.t
val p_end_of_part :
MrMime_content.t -> [ `End | `Next ] MrMime_parser.t
end
module Extension :
sig
val add_encoding :
string ->
(unit MrMime_parser.t ->
unit MrMime_parser.t -> encoding MrMime_parser.t) ->
unit
val add_content :
string ->
(string option ->
MrMime_content.t ->
field_message list -> content MrMime_parser.t) ->
unit
end
val of_string_raw :
?chunk:int ->
string ->
int ->
int ->
((MrMime_header.header * (encoding, content) message) * int) option
end
module Maildir :
sig
module Map :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
end
type safe
type unsafe
type 'a t = {
sequence : int option;
boot : int option;
crypto_random : int option;
inode : int option;
device : int option;
microsecond : int option;
pid : int option;
deliveries : int option;
}
val make :
?sequence:int ->
?boot:int ->
?crypto_random:int ->
?inode:int ->
?device:int ->
?microsecond:int -> ?pid:int -> ?deliveries:int -> unit -> unsafe t
val to_safe : unsafe t -> safe t option
type id = Modern of safe t | Old0 of int | Old1 of int * int
type flag = Passed | Replied | Seen | Trashed | Draft | Flagged
type 'a info = Exp of 'a | Info of flag list
type 'a filename = {
time : int;
id : id;
host : string;
parameters : string Map.t;
info : 'a info;
}
val pp : Format.formatter -> ('a, Format.formatter, unit) format -> 'a
val pp_lst :
sep:(Format.formatter -> unit -> unit) ->
(Format.formatter -> 'a -> unit) ->
Format.formatter -> 'a list -> unit
val pp_flag : Format.formatter -> flag -> unit
val pp_info :
(Format.formatter -> 'a -> unit) ->
Format.formatter -> 'a info -> unit
val pp_option :
(Format.formatter -> 'a -> unit) ->
Format.formatter -> 'a option -> unit
val pp_t : Format.formatter -> 'a t -> unit
val pp_id : Format.formatter -> id -> unit
val pp_map : Format.formatter -> string Map.t -> unit
val pp_filename :
(Format.formatter -> 'a -> unit) ->
Format.formatter -> 'a filename -> unit
type Parser.err += Invalid_filename
val implode : char list -> string
val avoid : unit Parser.t
val parse : 'a Parser.t -> 'a filename Parser.t
val of_filename : 'a Parser.t -> string -> 'a filename option
end
module Parser :
sig
module Input :
sig
type nonrec 'a t =
'a RingBuffer.Committed.t = {
mutable contents : 'a RingBuffer.t;
mutable mark : int option;
}
type mark = Weak of int | Uniq of int
val pp_with_mark : Format.formatter -> int * int * 'a t -> unit
val pp : Format.formatter -> 'a t -> unit
val copy : 'a t -> int -> 'a RingBuffer.t
val prepare : 'a t -> int -> 'a RingBuffer.t
val equal : mark -> mark -> bool
val mark : 'a t -> mark
val unmark : mark -> 'a t -> unit
val forget : mark -> 'a t -> unit
val write : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val write_string : 'a t -> string -> int -> int -> unit
val create_bytes : int -> Internal_buffer.st t
val create_bigstring : int -> Internal_buffer.bs t
val create_by : proof:'a Internal_buffer.t -> int -> 'a t
val size : 'a t -> int
val peek : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val read : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val read_space : 'a t -> ('a Internal_buffer.t * int * int) option
val write_space : 'a t -> ('a Internal_buffer.t * int * int) option
val transmit :
'a t -> ('a Internal_buffer.t -> int -> int -> int) -> int
val ravailable : 'a t -> int
val wavailable : 'a t -> int
val radvance : 'a t -> int -> unit
val wadvance : 'a t -> int -> unit
val get : 'a t -> char
val rollback : 'a t -> 'a Internal_buffer.t -> unit
val proof : 'a t -> 'a Internal_buffer.t
val savailable : 'a t -> int
end
type s = Parser.s = Complete | Incomplete
val pp : Format.formatter -> s -> unit
type err = Parser.err = ..
type ('a, 'input) state =
('a, 'input) Parser.state =
Read of { buffer : 'input Input.t;
k : int -> s -> ('a, 'input) state;
}
| Done of 'a
| Fail of string list * err
type ('a, 'input) k = 'input Input.t -> s -> 'a
type ('a, 'input) fail =
(string list -> err -> ('a, 'input) state, 'input) k
type ('a, 'r, 'input) success = ('a -> ('r, 'input) state, 'input) k
type 'a t =
'a Parser.t = {
f :
'r 'input.
(('r, 'input) fail ->
('a, 'r, 'input) success -> ('r, 'input) state, 'input)
k;
}
val return : 'a -> 'a t
val fail : err -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( <|> ) : 'a t -> 'a t -> 'a t
val ( <$> ) : ('a -> 'b) -> 'a t -> 'b t
val ( <* ) : 'a t -> 'b t -> 'a t
val ( *> ) : 'a t -> 'b t -> 'b t
val ( <*> ) : ('a -> 'b) t -> 'a t -> 'b t
val fix : ('a t -> 'a t) -> 'a t
val lift : ('a -> 'b) -> 'a t -> 'b t
val lift2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val lift3 : ('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val run : 'input Input.t -> 'a t -> ('a, 'input) state
val only : 'input Input.t -> 'a t -> ('a, 'input) state
type err += Satisfy
type err += String
type err += Repeat
val peek_chr : char option t
val peek_chr_exn : char t
val advance : int -> unit t
val satisfy : (char -> bool) -> char t
val string : (string -> string) -> string -> string t
val store : Buffer.t -> (char -> bool) -> int t
val recognize : (char -> bool) -> string t
val char : char -> char t
val many : 'a t -> 'a list t
val one : 'a t -> 'a list t
val option : 'a -> 'a t -> 'a t
val take : int -> string t
val list : 'a t list -> 'a list t
val count : int -> 'a t -> 'a list t
val repeat : int option -> int option -> (char -> bool) -> string t
end
module Input :
sig
type 'a t = 'a RingBuffer.Committed.t
type st = Internal_buffer.st = St
type bs = Internal_buffer.bs = Bs
val write : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val write_string : 'a t -> string -> int -> int -> unit
val create_bytes : int -> st t
val create_bigstring : int -> bs t
val size : 'a t -> int
val peek : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val read : 'a t -> 'a Internal_buffer.t -> int -> int -> unit
val read_space : 'a t -> ('a Internal_buffer.t * int * int) option
val write_space : 'a t -> ('a Internal_buffer.t * int * int) option
val transmit :
'a t -> ('a Internal_buffer.t -> int -> int -> int) -> int
val ravailable : 'a t -> int
val wavailable : 'a t -> int
val radvance : 'a t -> int -> unit
val wadvance : 'a t -> int -> unit
val get : 'a t -> char
val pp : Format.formatter -> 'a t -> unit
val proof : 'a t -> 'a Internal_buffer.t
val savailable : 'a t -> int
end
module Convenience :
sig
type 'a decoding =
[ `Continue | `Done of 'a | `Error of MrMime.Parser.err ]
type ('input, 'a) decoder
val decoder_src :
('input, 'a) MrMime.Convenience.decoder -> 'input MrMime.Input.t
val decoder :
'input MrMime.Input.t ->
'a MrMime.Parser.t -> ('input, 'a) MrMime.Convenience.decoder
val decode :
('input, 'a) MrMime.Convenience.decoder ->
'a MrMime.Convenience.decoding
val src :
('input, 'a) MrMime.Convenience.decoder ->
string -> int -> int -> unit
val decoding :
('input, 'a) MrMime.Convenience.decoder ->
'b MrMime.Parser.t -> ('input, 'b) MrMime.Convenience.decoder
end
end