--- Smdn.Formats.Mime-0.91-netstandard2.0.apilist.cs	2019-01-30 03:03:53.129712417 +0900
+++ Smdn.Formats.Mime-1.0alpha1-netstandard2.0.apilist.cs	2019-01-30 03:03:55.969665629 +0900
@@ -1,389 +1,391 @@
-// Smdn.Formats.Mime-0.91 (netstandard2.0)
+// Smdn.Formats.Mime-1.0alpha1 (netstandard2.0)
 //   Name: Smdn.Formats.Mime
 //   TargetFramework: .NETStandard,Version=v2.0
-//   AssemblyVersion: 0.91.0.0
-//   InformationalVersion: 0.91 (netstandard2.0)
+//   AssemblyVersion: 1.0.0.0
+//   InformationalVersion: 1.0alpha1 (netstandard2.0)
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.IO;
 using System.Security.Cryptography;
 using System.Text;
 using Smdn;
 using Smdn.Formats.Mime;
 using Smdn.Formats.Mime.Formatting;
 using Smdn.Text.Encodings;
 
 namespace Smdn.Formats.Mime {
   public interface IMimeMessage {
     MimeMessageDisposition Disposition { get; }
     MimeMessage EncapsulatedMessage { get; }
     MimeHeaderCollection Headers { get; }
     MimeType MimeType { get; }
     MimeMessage ParentPart { get; }
     MimeMessage RootPart { get; }
-    ReadOnlyCollection<MimeMessage> SubParts { get; }
+    IReadOnlyList<MimeMessage> SubParts { get; }
 
     void ReadContent(Action<BinaryReader> read);
     void ReadContent(Action<StreamReader> read);
     void ReadContent(bool decode, Action<Stream> read);
   }
 
   public enum MimeMessageDisposition : int {
     Attachment = 2,
     FormData = 3,
     Inline = 1,
     None = 0,
     Unknown = 4,
   }
 
   public class AttachedFile :
     MailBase,
     IMimeMessage
   {
     public DateTimeOffset? CreationDate { get; }
     public MimeMessageDisposition Disposition { get; }
     public string FileName { get; }
     public MimeHeaderCollection Headers { get; }
     public Mail Mail { get; }
     public MimeType MimeType { get; }
     public DateTimeOffset? ModificationDate { get; }
     public DateTimeOffset? ReadDate { get; }
     public long? Size { get; }
     MimeMessage IMimeMessage.EncapsulatedMessage { get; }
     MimeMessage IMimeMessage.ParentPart { get; }
     MimeMessage IMimeMessage.RootPart { get; }
-    ReadOnlyCollection<MimeMessage> IMimeMessage.SubParts { get; }
+    IReadOnlyList<MimeMessage> IMimeMessage.SubParts { get; }
 
     public static AttachedFile CreateFrom(MimeMessage baseMessage) {}
     public FileInfo Save() {}
     public FileInfo Save(string saveToDirectory) {}
   }
 
   public class Charsets {
     public Charsets() {}
 
     [Obsolete("deprecated, use System.Text.Encoding.ASCII instead", true)]
     public static Encoding ASCII { get; }
     [Obsolete("deprecated, use System.Text.Encoding.GetEncoding(\"ISO-8859-1\") instead", true)]
     public static Encoding Latin1 { get; }
     [Obsolete("deprecated, use System.Text.Encoding.UTF7 instead", true)]
     public static Encoding UTF7 { get; }
     [Obsolete("deprecated, use System.Text.Encoding.UTF8Encoding(false, true) instead", true)]
     public static Encoding UTF8 { get; }
 
     [Obsolete("deprecated, use Smdn.Text.Encodings.EncodingUtils.GetEncodingThrowException instead", true)]
     public static Encoding FromString(string name) {}
     [Obsolete("deprecated, use Smdn.Text.Encodings.EncodingUtils.GetEncodingThrowException instead", true)]
     public static Encoding FromString(string name, EncodingSelectionCallback selectFallbackCharset) {}
     [Obsolete("deprecated, use System.Text.Encoding.BodyName instead", true)]
     public static string ToString(Encoding encoding) {}
   }
 
   public class Mail :
     MailBase,
     IDisposable,
     IMimeMessage
   {
     public Mail(MimeMessage baseMessage) {}
 
-    public ReadOnlyCollection<AttachedFile> AttachedFiles { get; }
-    public IEnumerable<MimeMessage> AttachmentParts { get; }
+    public IReadOnlyList<AttachedFile> AttachedFiles { get; }
+    public IReadOnlyList<MimeMessage> AttachmentParts { get; }
     public DateTimeOffset? Date { get; }
     public string DateString { get; }
     public MimeMessageDisposition Disposition { get; }
     public MimeMessage EncapsulatedMessage { get; }
     public string From { get; }
     public MimeHeaderCollection Headers { get; }
     public string InReplyTo { get; }
-    public IEnumerable<MimeMessage> InlineMessageParts { get; }
+    public IReadOnlyList<MimeMessage> InlineMessageParts { get; }
     public string MessageId { get; }
     public MimeType MimeType { get; }
     public string References { get; }
     public string ReplyTo { get; }
     public string Sender { get; }
     MimeMessage IMimeMessage.ParentPart { get; }
     MimeMessage IMimeMessage.RootPart { get; }
-    public ReadOnlyCollection<MimeMessage> SubParts { get; }
+    public IReadOnlyList<MimeMessage> SubParts { get; }
     public string Subject { get; }
     public string To { get; }
     public string UserAgent { get; }
 
     public void Dispose() {}
     public string GetHeaderValueOf(string headerName) {}
     public string GetHeaderValueOf(string headerName, bool withParameter) {}
     public string GetHeaderValueOf(string headerName, bool withParameter, bool removeComment) {}
     public static Mail Load(Stream stream) {}
     public static Mail Load(Stream stream, Encoding fallbackCharset) {}
     public static Mail Load(Stream stream, EncodingSelectionCallback selectFallbackCharset) {}
     public static Mail Load(Stream stream, EncodingSelectionCallback selectFallbackCharset, MimeEncodedWordConverter decodeMalformedHeaderValue) {}
     public static Mail Load(string file) {}
     public static Mail Load(string file, Encoding fallbackCharset) {}
     public static Mail Load(string file, EncodingSelectionCallback selectFallbackCharset) {}
     public static Mail Load(string file, EncodingSelectionCallback selectFallbackCharset, MimeEncodedWordConverter decodeMalformedHeaderValue) {}
     public static Mail Load(string file, bool loadContentToMemory) {}
     public static Mail Load(string file, bool loadContentToMemory, Encoding fallbackCharset) {}
     public static Mail Load(string file, bool loadContentToMemory, EncodingSelectionCallback selectFallbackCharset) {}
     public static Mail Load(string file, bool loadContentToMemory, EncodingSelectionCallback selectFallbackCharset, MimeEncodedWordConverter decodeMalformedHeaderValue) {}
     public static Mail LoadMail(string mail) {}
     public static Mail LoadMail(string mail, Encoding fallbackCharset) {}
     public static Mail LoadMail(string mail, EncodingSelectionCallback selectFallbackCharset) {}
     public static Mail LoadMail(string mail, EncodingSelectionCallback selectFallbackCharset, MimeEncodedWordConverter decodeMalformedHeaderValue) {}
-    public FileInfo[] SaveAttachedFilesAs(Func<AttachedFile, string> selectFileName) {}
-    public FileInfo[] SaveAttachedFilesToDirectory(string directory) {}
+    public IReadOnlyList<FileInfo> SaveAttachedFilesAs(Func<AttachedFile, string> selectFileName) {}
+    public IReadOnlyList<FileInfo> SaveAttachedFilesToDirectory(string directory) {}
   }
 
   public abstract class MailBase {
     protected MailBase(MimeMessage baseMessage) {}
 
     public MimeMessage BaseMessage { get; }
 
     protected void CheckDisposed() {}
     public void CopyContentTo(Stream stream) {}
     public void CopyContentTo(Stream stream, bool decode) {}
     protected void DisposeCore() {}
     public void ReadContent(Action<BinaryReader> read) {}
     public void ReadContent(Action<Stream> read) {}
     public void ReadContent(Action<StreamReader> read) {}
     public void ReadContent(bool decode, Action<Stream> read) {}
     public byte[] ReadContentAsBinary() {}
     public string ReadContentAsText() {}
     public void SaveContent(string path) {}
     public void SaveContent(string path, bool decode) {}
     public override string ToString() {}
   }
 
   public class MimeHeader : ICloneable {
     public Encoding Charset { get; }
     public MimeEncodingMethod Encoding { get; }
     public string Name { get; }
     public string Value { get; }
 
     public MimeHeader Clone() {}
     public void ForEachParameter(Action<KeyValuePair<string, string>> action) {}
-    public KeyValuePair<string, string>[] GetAllParameters() {}
+    public IEnumerable<KeyValuePair<string, string>> GetAllParameters() {}
     public string GetParameter(string attr) {}
     public string GetValueWithoutParameter() {}
     public bool HasParameter(string attr) {}
     public bool IsNameEquals(string name) {}
     object ICloneable.Clone() {}
     public override string ToString() {}
   }
 
   public class MimeHeaderCollection : ReadOnlyCollection<MimeHeader> {
     public MimeHeader this[string name] { get; }
 
     public bool Contains(string name) {}
     public IEnumerable<MimeHeader> GetHeaders(string name) {}
     public bool TryGetHeader(string name, out MimeHeader header) {}
   }
 
   public static class MimeHeaderNames {
     public const string ContentDescription = "Content-Description";
     public const string ContentDisposition = "Content-Disposition";
     public const string ContentTransferEncoding = "Content-Transfer-Encoding";
     public const string ContentType = "Content-Type";
     public const string MimeVersion = "MIME-Version";
   }
 
   public class MimeMessage :
     IDisposable,
     IMimeMessage
   {
+    [Obsolete("use Flatten() instead")]
     public MimeMessage[] AllParts { get; }
     public string Boundary { get; }
     public Encoding Charset { get; }
     public MimeMessageDisposition Disposition { get; }
     public MimeMessage EncapsulatedMessage { get; }
     public MimeHeaderCollection Headers { get; }
     public MimeType MimeType { get; }
     public MimeMessage ParentPart { get; }
     public string PartSpecifier { get; }
     public MimeMessage RootPart { get; }
-    public ReadOnlyCollection<MimeMessage> SubParts { get; }
+    public IReadOnlyList<MimeMessage> SubParts { get; }
     public ContentTransferEncodingMethod TransferEncoding { get; }
 
     public void CopyContentTo(Stream stream) {}
     public void CopyContentTo(Stream stream, bool decode) {}
     public void Dispose() {}
+    public IEnumerable<MimeMessage> Flatten(bool containSelf = false) {}
     public static MimeMessage Load(Stream stream) {}
     public static MimeMessage Load(Stream stream, Encoding fallbackCharset) {}
     public static MimeMessage Load(Stream stream, EncodingSelectionCallback selectFallbackCharset) {}
     public static MimeMessage Load(Stream stream, EncodingSelectionCallback selectFallbackCharset, MimeEncodedWordConverter decodeMalformedHeaderValue) {}
     public static MimeMessage Load(string file) {}
     public static MimeMessage Load(string file, Encoding fallbackCharset) {}
     public static MimeMessage Load(string file, EncodingSelectionCallback selectFallbackCharset) {}
     public static MimeMessage Load(string file, EncodingSelectionCallback selectFallbackCharset, MimeEncodedWordConverter decodeMalformedHeaderValue) {}
     public static MimeMessage Load(string file, bool loadContentToMemory) {}
     public static MimeMessage Load(string file, bool loadContentToMemory, Encoding fallbackCharset) {}
     public static MimeMessage Load(string file, bool loadContentToMemory, EncodingSelectionCallback selectFallbackCharset) {}
     public static MimeMessage Load(string file, bool loadContentToMemory, EncodingSelectionCallback selectFallbackCharset, MimeEncodedWordConverter decodeMalformedHeaderValue) {}
     public static MimeMessage LoadMessage(string message) {}
     public static MimeMessage LoadMessage(string message, Encoding fallbackCharset) {}
     public static MimeMessage LoadMessage(string message, EncodingSelectionCallback selectFallbackCharset) {}
     public static MimeMessage LoadMessage(string message, EncodingSelectionCallback selectFallbackCharset, MimeEncodedWordConverter decodeMalformedHeaderValue) {}
     public void ReadContent(Action<BinaryReader> read) {}
     public void ReadContent(Action<Stream> read) {}
     public void ReadContent(Action<StreamReader> read) {}
     public void ReadContent(bool decode, Action<Stream> read) {}
     public byte[] ReadContentAsBinary() {}
     public string ReadContentAsText() {}
     public MimeMessage ReassembleFragmentedMessage(IMimeMessage fragmentedMessage, params IMimeMessage[] fragmentedMessages) {}
     public static MimeMessage ReassembleFragmentedMessage(IEnumerable<IMimeMessage> fragmentedMessages) {}
     public static MimeMessage ReassembleFragmentedMessage(IMimeMessage fragmentedMessage1, IMimeMessage fragmentedMessage2, params IMimeMessage[] fragmentedMessages) {}
     public void Save(Stream stream) {}
     public void Save(string path) {}
     public void SaveContent(string path) {}
     public void SaveContent(string path, bool decode) {}
     public override string ToString() {}
   }
 }
 
 namespace Smdn.Formats.Mime.Formatting {
   public enum NewLine : int {
     CR = 0,
     CRLF = 2,
     LF = 1,
     Standard = 2,
   }
 
   public class Base64ContentEncodingStream : ContentEncodingStream {
     public Base64ContentEncodingStream(Stream stream, MimeFormat format) {}
   }
 
   public abstract class ContentEncodingStream : Stream {
     protected ContentEncodingStream(Stream stream, ICryptoTransform transform, byte[] eolPrependBytes, MimeFormat format) {}
 
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
-    public byte[] EOL { get; }
+    public IReadOnlyList<byte> EOL { get; }
     protected Stream InnerStream { get; }
     public override long Length { get; }
     protected int LineLength { get; set; }
     public override long Position { get; set; }
 
     public override void Close() {}
     protected override void Dispose(bool disposing) {}
     public override void Flush() {}
     public virtual void FlushFinalBlock() {}
     public override int Read(byte[] dest, int offset, int count) {}
     public override long Seek(long offset, SeekOrigin origin) {}
     public override void SetLength(long @value) {}
     public override void Write(byte[] buffer, int offset, int count) {}
   }
 
   public static class ContentEncodingStreamUtils {
     public static Stream CreateEncodingStream(Stream contentStream, ContentTransferEncodingMethod transferEncoding) {}
     public static Stream CreateEncodingStream(Stream contentStream, ContentTransferEncodingMethod transferEncoding, MimeFormat format) {}
     public static Stream CreateEncodingStream(Stream contentStream, string transferEncoding) {}
   }
 
   public class MimeFormat {
     public static readonly MimeFormat Standard; // = "Smdn.Formats.Mime.Formatting.MimeFormat"
 
     public MimeFormat() {}
     public MimeFormat(int folding, NewLine newLine) {}
 
     public int Folding { get; set; }
     public NewLine NewLine { get; set; }
 
     public byte[] GetEOLBytes() {}
     public string GetEOLString() {}
     public string GetHeaderFoldingString() {}
   }
 
   public class MimeHeaderBuilder {
     public MimeHeaderBuilder(string name) {}
     public MimeHeaderBuilder(string name, IEnumerable<MimeHeaderFragment> headerFragments) {}
     public MimeHeaderBuilder(string name, MimeFormat format, IEnumerable<MimeHeaderFragment> headerFragments) {}
     public MimeHeaderBuilder(string name, string @value) {}
     public MimeHeaderBuilder(string name, string @value, MimeEncodingMethod encoding) {}
     public MimeHeaderBuilder(string name, string @value, MimeEncodingMethod encoding, Encoding charset) {}
     public MimeHeaderBuilder(string name, string @value, MimeFormat format) {}
     public MimeHeaderBuilder(string name, string @value, MimeFormat format, MimeEncodingMethod encoding) {}
     public MimeHeaderBuilder(string name, string @value, MimeFormat format, MimeEncodingMethod encoding, Encoding charset) {}
 
     public Encoding Charset { get; set; }
     public MimeEncodingMethod Encoding { get; set; }
     public MimeFormat Format { get; set; }
     public string Name { get; }
     public string Value { get; set; }
 
     public static MimeHeaderBuilder CreateContentDisposition(MimeMessageDisposition disposition, string filename) {}
     public static MimeHeaderBuilder CreateContentTransferEncoding(ContentTransferEncodingMethod transferEncoding) {}
     public static MimeHeaderBuilder CreateContentTransferEncoding(MimeFormat format, ContentTransferEncodingMethod transferEncoding) {}
     public static MimeHeaderBuilder CreateContentType(MimeFormat format, MimeType mimeType, Encoding charset) {}
     public static MimeHeaderBuilder CreateContentType(MimeFormat format, MimeType mimeType, Encoding charset, string boundary) {}
     public static MimeHeaderBuilder CreateContentType(MimeFormat format, MimeType mimeType, Encoding charset, string boundary, string name) {}
     public static MimeHeaderBuilder CreateContentType(MimeType mimeType) {}
     public static MimeHeaderBuilder CreateContentType(MimeType mimeType, Encoding charset) {}
     public static MimeHeaderBuilder CreateContentType(MimeType mimeType, Encoding charset, string boundary) {}
     public static MimeHeaderBuilder CreateContentType(MimeType mimeType, Encoding charset, string boundary, string name) {}
     public bool IsNameEquals(string name) {}
     public void SetValue(MimeFormat format, IEnumerable<MimeHeaderFragment> headerFragments) {}
     public override string ToString() {}
   }
 
   public class MimeHeaderFragment {
     public MimeHeaderFragment(string @value) {}
     public MimeHeaderFragment(string @value, MimeEncodingMethod encoding, Encoding charset) {}
 
     public Encoding Charset { get; }
     public MimeEncodingMethod Encoding { get; }
     public string Value { get; }
 
     public override string ToString() {}
   }
 
   public class MimeHeaderParameterFragment : MimeHeaderFragment {
     public MimeHeaderParameterFragment(string @value) {}
     public MimeHeaderParameterFragment(string @value, MimeEncodingMethod encoding, Encoding charset) {}
     public MimeHeaderParameterFragment(string name, string @value) {}
     public MimeHeaderParameterFragment(string name, string @value, MimeEncodingMethod encoding, Encoding charset) {}
   }
 
   public class MimeMessageBuilder : IDisposable {
     public MimeMessageBuilder() {}
     public MimeMessageBuilder(IEnumerable<MimeHeaderBuilder> headers) {}
     public MimeMessageBuilder(IEnumerable<MimeHeaderBuilder> headers, IEnumerable<MimeMessageBuilder> subParts) {}
     public MimeMessageBuilder(IEnumerable<MimeMessageBuilder> subParts) {}
 
     public string Boundary { get; set; }
     public Encoding Charset { get; set; }
     public MimeMessageDisposition Disposition { get; set; }
     public MimeFormat Format { get; set; }
     public List<MimeHeaderBuilder> Headers { get; }
     public MimeType MimeType { get; set; }
     public List<MimeMessageBuilder> SubParts { get; }
     public ContentTransferEncodingMethod TransferEncoding { get; set; }
 
     public static MimeMessageBuilder CreateAttachment(Stream contentStream, MimeType mimeType) {}
     public static MimeMessageBuilder CreateAttachment(Stream contentStream, MimeType mimeType, bool inline) {}
     public static MimeMessageBuilder CreateAttachment(Stream contentStream, MimeType mimeType, string filename, bool inline) {}
     public static MimeMessageBuilder CreateAttachment(Stream contentStream, MimeType mimeType, string filename, string description, bool inline) {}
     public static MimeMessageBuilder CreateAttachment(string file) {}
     public static MimeMessageBuilder CreateAttachment(string file, bool inline) {}
     public static MimeMessageBuilder CreateAttachment(string file, string description, bool inline) {}
     public static MimeMessageBuilder CreateMultipart(IEnumerable<MimeMessageBuilder> subParts) {}
     public void Dispose() {}
     public IEnumerable<MimeHeaderBuilder> GetHeaders(string name) {}
     public void Save(Stream stream) {}
     public void Save(string file) {}
     public override string ToString() {}
     public void WriteContent(ContentTransferEncodingMethod transferEncoding, Action<BinaryWriter> write) {}
     public void WriteContent(ContentTransferEncodingMethod transferEncoding, Encoding charset, Action<StreamWriter> write) {}
     public void WriteContent(byte[] content, ContentTransferEncodingMethod transferEncoding) {}
     public void WriteContent(byte[] content, int index, int count, ContentTransferEncodingMethod transferEncoding) {}
     public void WriteContent(string content, ContentTransferEncodingMethod transferEncoding, Encoding charset) {}
   }
 
   public class QuotedPrintableContentEncodingStream : ContentEncodingStream {
     public QuotedPrintableContentEncodingStream(Stream stream, MimeFormat format) {}
 
     public override void Write(byte[] buffer, int offset, int count) {}
   }
 }