3.0beta3-netstandard2.0_vs_3.0beta4-netstandard2.0.apilist.diff
--- Smdn-3.0beta3-netstandard2.0.apilist.cs	2019-03-23 14:48:38.000000000 +0900
+++ Smdn-3.0beta4-netstandard2.0.apilist.cs	2019-03-23 14:48:41.000000000 +0900
@@ -1,1825 +1,1829 @@
-// Smdn-3.0beta3 (netstandard2.0)
+// Smdn-3.0beta4 (netstandard2.0)
 //   Name: Smdn
 //   TargetFramework: .NETStandard,Version=v2.0
 //   AssemblyVersion: 3.0.0.0
-//   InformationalVersion: 3.0beta3 (netstandard2.0)
+//   InformationalVersion: 3.0beta4 (netstandard2.0)
 
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Net.NetworkInformation;
 using System.Runtime.Serialization;
 using System.Security.Cryptography;
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
 using Smdn;
 using Smdn.Formats;
 using Smdn.Formats.Mime;
 using Smdn.Formats.ModifiedBase64;
 using Smdn.Formats.PercentEncodings;
 using Smdn.Formats.QuotedPrintableEncodings;
 using Smdn.Formats.UUEncodings;
 using Smdn.IO.Binary;
 using Smdn.IO.Streams;
 using Smdn.IO.Streams.Caching;
 using Smdn.IO.Streams.LineOriented;
 using Smdn.OperatingSystem;
 using Smdn.Text;
 using Smdn.Text.Encodings;
 
 namespace Smdn {
   public enum Endianness : int {
     BigEndian = 0,
     LittleEndian = 1,
     Unknown = 2,
   }
 
   public enum RuntimeEnvironment : int {
     Mono = 2,
     NetCore = 3,
     NetFx = 1,
     Unknown = 0,
   }
 
   public enum UuidVersion : byte {
     NameBasedMD5Hash = 3,
     NameBasedSHA1Hash = 5,
     None = 0,
     RandomNumber = 4,
     TimeBased = 1,
     Version1 = 1,
     Version2 = 2,
     Version3 = 3,
     Version4 = 4,
     Version5 = 5,
   }
 
   public static class ArrayExtensions {
     public static T[] Append<T>(this T[] array, T element, params T[] elements) {}
     public static T[] Concat<T>(this T[] array, params T[][] arrays) {}
     public static TOutput[] Convert<TInput, TOutput>(this TInput[] array, Converter<TInput, TOutput> converter) {}
     public static T[] Prepend<T>(this T[] array, T element, params T[] elements) {}
     public static T[] Shuffle<T>(this T[] array) {}
     public static T[] Shuffle<T>(this T[] array, Random random) {}
     public static T[] Slice<T>(this T[] array, int start) {}
     public static T[] Slice<T>(this T[] array, int start, int count) {}
   }
 
   public static class ExceptionUtils {
     public static ArgumentException CreateAllItemsOfArgumentMustBeNonNull(string paramName) {}
     public static ArgumentException CreateArgumentAttemptToAccessBeyondEndOfArray(string paramName, Array array, long offsetValue, long countValue) {}
     public static ArgumentException CreateArgumentAttemptToAccessBeyondEndOfCollection<T>(string paramName, IReadOnlyCollection<T> collection, long offsetValue, long countValue) {}
     public static ArgumentOutOfRangeException CreateArgumentMustBeGreaterThan(object minValue, string paramName, object actualValue) {}
     public static ArgumentOutOfRangeException CreateArgumentMustBeGreaterThanOrEqualTo(object minValue, string paramName, object actualValue) {}
     public static ArgumentOutOfRangeException CreateArgumentMustBeInRange(object rangeFrom, object rangeTo, string paramName, object actualValue) {}
     public static ArgumentOutOfRangeException CreateArgumentMustBeLessThan(object maxValue, string paramName, object actualValue) {}
     public static ArgumentOutOfRangeException CreateArgumentMustBeLessThanOrEqualTo(object maxValue, string paramName, object actualValue) {}
     public static ArgumentException CreateArgumentMustBeMultipleOf(int n, string paramName) {}
     public static ArgumentException CreateArgumentMustBeNonEmptyArray(string paramName) {}
     public static ArgumentException CreateArgumentMustBeNonEmptyCollection(string paramName) {}
     public static ArgumentException CreateArgumentMustBeNonEmptyString(string paramName) {}
     public static ArgumentOutOfRangeException CreateArgumentMustBeNonZeroPositive(string paramName, object actualValue) {}
     public static ArgumentException CreateArgumentMustBeReadableStream(string paramName) {}
     public static ArgumentException CreateArgumentMustBeSeekableStream(string paramName) {}
     public static ArgumentException CreateArgumentMustBeValidEnumValue<TEnum>(string paramName, TEnum invalidValue) where TEnum : Enum {}
     public static ArgumentException CreateArgumentMustBeValidEnumValue<TEnum>(string paramName, TEnum invalidValue, string additionalMessage) where TEnum : Enum {}
     public static ArgumentException CreateArgumentMustBeValidIAsyncResult(string paramName) {}
     public static ArgumentException CreateArgumentMustBeWritableStream(string paramName) {}
     public static ArgumentOutOfRangeException CreateArgumentMustBeZeroOrPositive(string paramName, object actualValue) {}
     public static IOException CreateIOAttemptToSeekBeforeStartOfStream() {}
     public static NotSupportedException CreateNotSupportedEnumValue<TEnum>(TEnum unsupportedValue) where TEnum : Enum {}
     public static NotSupportedException CreateNotSupportedReadingStream() {}
     public static NotSupportedException CreateNotSupportedSeekingStream() {}
     public static NotSupportedException CreateNotSupportedSettingStreamLength() {}
     public static NotSupportedException CreateNotSupportedWritingStream() {}
   }
 
   public static class MathUtils {
     public static int Gcd(int m, int n) {}
     public static long Gcd(long m, long n) {}
     public static byte[] GetRandomBytes(int length) {}
     public static void GetRandomBytes(byte[] bytes) {}
     public static double Hypot(double x, double y) {}
     public static float Hypot(float x, float y) {}
     public static bool IsPrimeNumber(long n) {}
     public static int Lcm(int m, int n) {}
     public static long Lcm(long m, long n) {}
     public static long NextPrimeNumber(long n) {}
   }
 
   public class MimeType :
     IEquatable<MimeType>,
     IEquatable<string>
   {
     public static readonly MimeType ApplicationOctetStream; // = "application/octet-stream"
     public static readonly MimeType MessageExternalBody; // = "message/external-body"
     public static readonly MimeType MessagePartial; // = "message/partial"
     public static readonly MimeType MessageRfc822; // = "message/rfc822"
     public static readonly MimeType MultipartAlternative; // = "multipart/alternative"
     public static readonly MimeType MultipartMixed; // = "multipart/mixed"
     public static readonly MimeType TextPlain; // = "text/plain"
 
     public MimeType((string type, string subType) mimeType) {}
     public MimeType(string mimeType) {}
     public MimeType(string type, string subType) {}
 
     public string SubType { get; }
     public string Type { get; }
 
     public static MimeType CreateApplicationType(string subtype) {}
     public static MimeType CreateAudioType(string subtype) {}
     public static MimeType CreateImageType(string subtype) {}
     public static MimeType CreateMultipartType(string subtype) {}
     public static MimeType CreateTextType(string subtype) {}
     public static MimeType CreateVideoType(string subtype) {}
     public void Deconstruct(out string type, out string subType) {}
     public bool Equals(MimeType other) {}
     public bool Equals(string other) {}
     public override bool Equals(object obj) {}
     public bool EqualsIgnoreCase(MimeType other) {}
     public bool EqualsIgnoreCase(string other) {}
     public static IEnumerable<string> FindExtensionsByMimeType(MimeType mimeType) {}
     public static IEnumerable<string> FindExtensionsByMimeType(MimeType mimeType, string mimeTypesFile) {}
     public static IEnumerable<string> FindExtensionsByMimeType(string mimeType) {}
     public static IEnumerable<string> FindExtensionsByMimeType(string mimeType, string mimeTypesFile) {}
     public static MimeType FindMimeTypeByExtension(string extensionOrPath) {}
     public static MimeType FindMimeTypeByExtension(string extensionOrPath, string mimeTypesFile) {}
     public override int GetHashCode() {}
     public static (string type, string subType) Parse(string s) {}
     public bool SubTypeEquals(MimeType mimeType) {}
     public bool SubTypeEquals(string subType) {}
     public bool SubTypeEqualsIgnoreCase(MimeType mimeType) {}
     public bool SubTypeEqualsIgnoreCase(string subType) {}
     public override string ToString() {}
     public static bool TryParse(string s, out (string type, string subType) result) {}
     public static bool TryParse(string s, out MimeType result) {}
     public bool TypeEquals(MimeType mimeType) {}
     public bool TypeEquals(string type) {}
     public bool TypeEqualsIgnoreCase(MimeType mimeType) {}
     public bool TypeEqualsIgnoreCase(string type) {}
     public static explicit operator string(MimeType mimeType) {}
   }
 
   public static class ParamArrayUtils {
     public static IEnumerable<TParam> ToEnumerable<TParam>(TParam first, params TParam[] subsequence) {}
     public static IEnumerable<TParam> ToEnumerableNonNullable<TParam>(string paramName, TParam first, params TParam[] subsequence) where TParam : class {}
+    public static IReadOnlyList<TParam> ToList<TParam>(TParam first, params TParam[] subsequence) {}
+    public static IReadOnlyList<TParam> ToListNonNullable<TParam>(string paramName, TParam first, params TParam[] subsequence) where TParam : class {}
   }
 
   public static class Platform {
     public static readonly Endianness Endianness = Endianness.LittleEndian;
 
     public static string DistributionName { get; }
     public static bool IsRunningOnUnix { get; }
     public static bool IsRunningOnWindows { get; }
     public static string KernelName { get; }
     public static StringComparer PathStringComparer { get; }
     public static StringComparison PathStringComparison { get; }
     public static string ProcessorName { get; }
   }
 
   public static class Runtime {
     public static bool IsRunningOnMono { get; }
     public static bool IsRunningOnNetCore { get; }
     public static bool IsRunningOnNetFx { get; }
     [Obsolete("use Smdn.Platform.IsRunningOnWindows")]
     public static bool IsRunningOnUnix { get; }
     [Obsolete("use Smdn.Platform.IsRunningOnWindows")]
     public static bool IsRunningOnWindows { get; }
     public static string Name { get; }
     public static RuntimeEnvironment RuntimeEnvironment { get; }
     public static Version Version { get; }
     public static string VersionString { get; }
   }
 
   public static class StringExtensions {
     public delegate string ReplaceCharEvaluator(char ch, string str, int index);
     public delegate string ReplaceStringEvaluator(string matched, string str, int index);
 
     public static int Count(this string str, char c) {}
     public static int Count(this string str, string substr) {}
     public static bool EndsWith(this string str, char @value) {}
     public static int IndexOfNot(this string str, char @value) {}
     public static int IndexOfNot(this string str, char @value, int startIndex) {}
     public static string Remove(this string str, params string[] oldValues) {}
     public static string RemoveChars(this string str, params char[] oldChars) {}
     public static string Replace(this string str, char[] oldChars, StringExtensions.ReplaceCharEvaluator evaluator) {}
     public static string Replace(this string str, string[] oldValues, StringExtensions.ReplaceStringEvaluator evaluator) {}
     public static string Slice(this string str, int from, int to) {}
     public static bool StartsWith(this string str, char @value) {}
   }
 
   public struct FourCC :
     IEquatable<FourCC>,
     IEquatable<byte[]>,
     IEquatable<string>
   {
     public static readonly FourCC Empty; // = "\u0000\u0000\u0000\u0000"
 
     public FourCC(byte[] @value) {}
     public FourCC(byte[] @value, int startIndex) {}
     public FourCC(string @value) {}
 
     public static FourCC CreateBigEndian(int bigEndianInt) {}
     public static FourCC CreateLittleEndian(int littleEndianInt) {}
     public bool Equals(FourCC other) {}
     public bool Equals(byte[] other) {}
     public bool Equals(string other) {}
     public override bool Equals(object obj) {}
     public void GetBytes(byte[] buffer, int startIndex) {}
     public override int GetHashCode() {}
     public byte[] ToByteArray() {}
     public Guid ToCodecGuid() {}
     public int ToInt32BigEndian() {}
     public int ToInt32LittleEndian() {}
     public override string ToString() {}
     public static bool operator == (FourCC x, FourCC y) {}
     public static explicit operator FourCC(byte[] fourccByteArray) {}
     public static explicit operator byte[](FourCC fourcc) {}
     public static explicit operator string(FourCC fourcc) {}
     public static implicit operator FourCC(string fourccString) {}
     public static bool operator != (FourCC x, FourCC y) {}
   }
 
   [StructLayout(LayoutKind.Explicit, Pack = 1)]
   public struct UInt24 :
     IComparable,
     IComparable<UInt24>,
     IComparable<int>,
     IComparable<uint>,
     IConvertible,
     IEquatable<UInt24>,
     IEquatable<int>,
     IEquatable<uint>,
     IFormattable
   {
     [FieldOffset(0)]
     public byte Byte0;
     [FieldOffset(1)]
     public byte Byte1;
     [FieldOffset(2)]
     public byte Byte2;
     public static readonly UInt24 MaxValue; // = "16777215"
     public static readonly UInt24 MinValue; // = "0"
     public static readonly UInt24 Zero; // = "0"
 
     public int CompareTo(UInt24 other) {}
     public int CompareTo(int other) {}
     public int CompareTo(object obj) {}
     public int CompareTo(uint other) {}
     public bool Equals(UInt24 other) {}
     public bool Equals(int other) {}
     public bool Equals(uint other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     TypeCode IConvertible.GetTypeCode() {}
     bool IConvertible.ToBoolean(IFormatProvider provider) {}
     byte IConvertible.ToByte(IFormatProvider provider) {}
     char IConvertible.ToChar(IFormatProvider provider) {}
     DateTime IConvertible.ToDateTime(IFormatProvider provider) {}
     decimal IConvertible.ToDecimal(IFormatProvider provider) {}
     double IConvertible.ToDouble(IFormatProvider provider) {}
     short IConvertible.ToInt16(IFormatProvider provider) {}
     int IConvertible.ToInt32(IFormatProvider provider) {}
     long IConvertible.ToInt64(IFormatProvider provider) {}
     sbyte IConvertible.ToSByte(IFormatProvider provider) {}
     float IConvertible.ToSingle(IFormatProvider provider) {}
     string IConvertible.ToString(IFormatProvider provider) {}
     object IConvertible.ToType(Type conversionType, IFormatProvider provider) {}
     ushort IConvertible.ToUInt16(IFormatProvider provider) {}
     uint IConvertible.ToUInt32(IFormatProvider provider) {}
     ulong IConvertible.ToUInt64(IFormatProvider provider) {}
     public int ToInt32() {}
     public override string ToString() {}
     public string ToString(IFormatProvider formatProvider) {}
     public string ToString(string format) {}
     public string ToString(string format, IFormatProvider formatProvider) {}
     public uint ToUInt32() {}
     public static bool operator == (UInt24 x, UInt24 y) {}
     public static explicit operator UInt24(int val) {}
     public static explicit operator UInt24(short val) {}
     public static explicit operator UInt24(uint val) {}
     public static explicit operator UInt24(ushort val) {}
     public static explicit operator int(UInt24 val) {}
     public static explicit operator short(UInt24 val) {}
     public static explicit operator uint(UInt24 val) {}
     public static explicit operator ushort(UInt24 val) {}
     public static bool operator != (UInt24 x, UInt24 y) {}
   }
 
   [StructLayout(LayoutKind.Explicit, Pack = 1)]
   public struct UInt48 :
     IComparable,
     IComparable<UInt48>,
     IComparable<long>,
     IComparable<ulong>,
     IConvertible,
     IEquatable<UInt48>,
     IEquatable<long>,
     IEquatable<ulong>,
     IFormattable
   {
     [FieldOffset(0)]
     public byte Byte0;
     [FieldOffset(1)]
     public byte Byte1;
     [FieldOffset(2)]
     public byte Byte2;
     [FieldOffset(3)]
     public byte Byte3;
     [FieldOffset(4)]
     public byte Byte4;
     [FieldOffset(5)]
     public byte Byte5;
     public static readonly UInt48 MaxValue; // = "281474976710655"
     public static readonly UInt48 MinValue; // = "0"
     public static readonly UInt48 Zero; // = "0"
 
     public int CompareTo(UInt48 other) {}
     public int CompareTo(long other) {}
     public int CompareTo(object obj) {}
     public int CompareTo(ulong other) {}
     public bool Equals(UInt48 other) {}
     public bool Equals(long other) {}
     public bool Equals(ulong other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     TypeCode IConvertible.GetTypeCode() {}
     bool IConvertible.ToBoolean(IFormatProvider provider) {}
     byte IConvertible.ToByte(IFormatProvider provider) {}
     char IConvertible.ToChar(IFormatProvider provider) {}
     DateTime IConvertible.ToDateTime(IFormatProvider provider) {}
     decimal IConvertible.ToDecimal(IFormatProvider provider) {}
     double IConvertible.ToDouble(IFormatProvider provider) {}
     short IConvertible.ToInt16(IFormatProvider provider) {}
     int IConvertible.ToInt32(IFormatProvider provider) {}
     long IConvertible.ToInt64(IFormatProvider provider) {}
     sbyte IConvertible.ToSByte(IFormatProvider provider) {}
     float IConvertible.ToSingle(IFormatProvider provider) {}
     string IConvertible.ToString(IFormatProvider provider) {}
     object IConvertible.ToType(Type conversionType, IFormatProvider provider) {}
     ushort IConvertible.ToUInt16(IFormatProvider provider) {}
     uint IConvertible.ToUInt32(IFormatProvider provider) {}
     ulong IConvertible.ToUInt64(IFormatProvider provider) {}
     public long ToInt64() {}
     public override string ToString() {}
     public string ToString(IFormatProvider formatProvider) {}
     public string ToString(string format) {}
     public string ToString(string format, IFormatProvider formatProvider) {}
     public ulong ToUInt64() {}
     public static bool operator == (UInt48 x, UInt48 y) {}
     public static explicit operator UInt48(int val) {}
     public static explicit operator UInt48(long val) {}
     public static explicit operator UInt48(uint val) {}
     public static explicit operator UInt48(ulong val) {}
     public static explicit operator int(UInt48 val) {}
     public static explicit operator long(UInt48 val) {}
     public static explicit operator uint(UInt48 val) {}
     public static explicit operator ulong(UInt48 val) {}
     public static bool operator != (UInt48 x, UInt48 y) {}
   }
 
   [StructLayout(LayoutKind.Explicit, Pack = 1)]
   public struct Uuid :
     IComparable,
     IComparable<Guid>,
     IComparable<Uuid>,
     IEquatable<Guid>,
     IEquatable<Uuid>,
     IFormattable
   {
     public enum Namespace : int {
       RFC4122Dns = 1806153744,
       RFC4122IsoOid = 1806153746,
       RFC4122Url = 1806153745,
       RFC4122X500 = 1806153748,
     }
 
     public enum Variant : byte {
       MicrosoftReserved = 192,
       NCSReserved = 0,
       RFC4122 = 128,
       Reserved = 224,
     }
 
     public static readonly Uuid Nil; // = "00000000-0000-0000-0000-000000000000"
     public static readonly Uuid RFC4122NamespaceDns; // = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
     public static readonly Uuid RFC4122NamespaceIsoOid; // = "6ba7b812-9dad-11d1-80b4-00c04fd430c8"
     public static readonly Uuid RFC4122NamespaceUrl; // = "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
     public static readonly Uuid RFC4122NamespaceX500; // = "6ba7b814-9dad-11d1-80b4-00c04fd430c8"
 
     public Uuid(Guid guid) {}
     public Uuid(byte[] octets) {}
     public Uuid(byte[] octets, int index) {}
     public Uuid(byte[] octets, int index, Endianness endian) {}
     public Uuid(string uuid) {}
     public Uuid(uint time_low, ushort time_mid, ushort time_hi_and_version, byte clock_seq_hi_and_reserved, byte clock_seq_low, PhysicalAddress node) {}
     public Uuid(uint time_low, ushort time_mid, ushort time_hi_and_version, byte clock_seq_hi_and_reserved, byte clock_seq_low, byte node0, byte node1, byte node2, byte node3, byte node4, byte node5) {}
     public Uuid(uint time_low, ushort time_mid, ushort time_hi_and_version, byte clock_seq_hi_and_reserved, byte clock_seq_low, byte[] node) {}
 
     public int Clock { get; }
     public byte ClockSeqHighAndReserved { get; }
     public byte ClockSeqLow { get; }
     public string IEEE802MacAddress { get; }
     public byte[] Node { get; }
     public PhysicalAddress PhysicalAddress { get; }
     public ushort TimeHighAndVersion { get; }
     public uint TimeLow { get; }
     public ushort TimeMid { get; }
     public DateTime Timestamp { get; }
     public Uuid.Variant VariantField { get; }
     public UuidVersion Version { get; }
 
     public int CompareTo(Guid other) {}
     public int CompareTo(Uuid other) {}
     public int CompareTo(object obj) {}
     public static Uuid CreateFromRandomNumber() {}
     public static Uuid CreateFromRandomNumber(RandomNumberGenerator rng) {}
     public static Uuid CreateFromRandomNumber(byte[] randomNumber) {}
     public static Uuid CreateNameBased(Uri url, UuidVersion version) {}
     public static Uuid CreateNameBased(byte[] name, Uuid namespaceId, UuidVersion version) {}
     public static Uuid CreateNameBased(byte[] name, Uuid.Namespace ns, UuidVersion version) {}
     public static Uuid CreateNameBased(string name, Uuid namespaceId, UuidVersion version) {}
     public static Uuid CreateNameBased(string name, Uuid.Namespace ns, UuidVersion version) {}
     public static Uuid CreateNameBasedMD5(Uri url) {}
     public static Uuid CreateNameBasedMD5(byte[] name, Uuid.Namespace ns) {}
     public static Uuid CreateNameBasedMD5(string name, Uuid.Namespace ns) {}
     public static Uuid CreateNameBasedSHA1(Uri url) {}
     public static Uuid CreateNameBasedSHA1(byte[] name, Uuid.Namespace ns) {}
     public static Uuid CreateNameBasedSHA1(string name, Uuid.Namespace ns) {}
     public static Uuid CreateTimeBased() {}
     public static Uuid CreateTimeBased(DateTime timestamp, int clock) {}
     public static Uuid CreateTimeBased(DateTime timestamp, int clock, PhysicalAddress node) {}
     public static Uuid CreateTimeBased(DateTime timestamp, int clock, byte[] node) {}
     public static Uuid CreateTimeBased(PhysicalAddress node) {}
     public static Uuid CreateTimeBased(byte[] node) {}
     public bool Equals(Guid other) {}
     public bool Equals(Uuid other) {}
     public override bool Equals(object obj) {}
     public void GetBytes(byte[] buffer, int startIndex) {}
     public void GetBytes(byte[] buffer, int startIndex, Endianness endian) {}
     public override int GetHashCode() {}
     public static Uuid NewUuid() {}
     public byte[] ToByteArray() {}
     public byte[] ToByteArray(Endianness endian) {}
     public Guid ToGuid() {}
     public override string ToString() {}
     public string ToString(string format) {}
     public string ToString(string format, IFormatProvider formatProvider) {}
     public static bool operator == (Uuid x, Uuid y) {}
     public static explicit operator Guid(Uuid @value) {}
     public static explicit operator Uuid(Guid @value) {}
     public static bool operator > (Uuid x, Uuid y) {}
     public static bool operator >= (Uuid x, Uuid y) {}
     public static bool operator != (Uuid x, Uuid y) {}
     public static bool operator < (Uuid x, Uuid y) {}
     public static bool operator <= (Uuid x, Uuid y) {}
   }
 }
 
 namespace Smdn.Collections {
   public static class IReadOnlyCollectionExtensions {
     public static List<TOutput> ConvertAll<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, Converter<TInput, TOutput> converter) {}
   }
 
   public static class IReadOnlyListExtensions {
     public static IReadOnlyList<T> Slice<T>(this IReadOnlyList<T> list, int index) {}
     public static IReadOnlyList<T> Slice<T>(this IReadOnlyList<T> list, int index, int count) {}
   }
 
   public static class KeyValuePair {
     public static KeyValuePair<TKey, TValue> Create<TKey, TValue>(TKey key, TValue @value) {}
   }
 
   public static class ReadOnlyDictionary<TKey, TValue> {
     public static readonly IReadOnlyDictionary<TKey, TValue> Empty;
   }
 
   public static class Singleton {
     public static IReadOnlyList<T> CreateList<T>(T element) {}
   }
 }
 
 namespace Smdn.Formats {
   public static class Base64 {
     public static Stream CreateDecodingStream(Stream stream, bool leaveStreamOpen = false) {}
     public static Stream CreateEncodingStream(Stream stream, bool leaveStreamOpen = false) {}
     public static ICryptoTransform CreateFromBase64Transform(bool ignoreWhiteSpaces = true) {}
     public static ICryptoTransform CreateToBase64Transform() {}
     public static byte[] Decode(byte[] bytes) {}
     public static byte[] Decode(byte[] bytes, int offset, int count) {}
     public static byte[] Decode(string str) {}
     public static byte[] Encode(byte[] bytes) {}
     public static byte[] Encode(byte[] bytes, int offset, int count) {}
     public static byte[] Encode(string str) {}
     public static byte[] Encode(string str, Encoding encoding) {}
     public static string GetDecodedString(byte[] bytes) {}
     public static string GetDecodedString(byte[] bytes, int offset, int count) {}
     public static string GetDecodedString(string str) {}
     public static string GetDecodedString(string str, Encoding encoding) {}
     public static string GetEncodedString(byte[] bytes) {}
     public static string GetEncodedString(byte[] bytes, int offset, int count) {}
     public static string GetEncodedString(string str) {}
     public static string GetEncodedString(string str, Encoding encoding) {}
   }
 
   public static class CsvRecord {
     public static string ToJoined(params string[] csv) {}
     public static string ToJoinedNullable(params string[] csv) {}
     public static string[] ToSplitted(string csv) {}
     public static string[] ToSplittedNullable(string csv) {}
   }
 
   public static class DateTimeFormat {
     public static DateTimeOffset FromISO8601DateTimeOffsetString(string s) {}
     public static DateTime FromISO8601DateTimeString(string s) {}
     public static DateTimeOffset FromRFC822DateTimeOffsetString(string s) {}
     public static DateTimeOffset? FromRFC822DateTimeOffsetStringNullable(string s) {}
     public static DateTime FromRFC822DateTimeString(string s) {}
     public static DateTimeOffset FromW3CDateTimeOffsetString(string s) {}
     public static DateTimeOffset? FromW3CDateTimeOffsetStringNullable(string s) {}
     public static DateTime FromW3CDateTimeString(string s) {}
     public static string GetCurrentTimeZoneOffsetString(bool delimiter) {}
     public static string ToISO8601DateTimeString(DateTime dateTime) {}
     public static string ToISO8601DateTimeString(DateTimeOffset dateTimeOffset) {}
     public static string ToRFC822DateTimeString(DateTime dateTime) {}
     public static string ToRFC822DateTimeString(DateTimeOffset dateTimeOffset) {}
     public static string ToRFC822DateTimeStringNullable(DateTimeOffset? dateTimeOffset) {}
     public static string ToW3CDateTimeString(DateTime dateTime) {}
     public static string ToW3CDateTimeString(DateTimeOffset dateTimeOffset) {}
     public static string ToW3CDateTimeStringNullable(DateTimeOffset? dateTimeOffset) {}
   }
 
   public static class Html {
     public static string FromHtmlEscapedString(string str) {}
     public static string FromHtmlEscapedStringNullable(string str) {}
     public static string FromNumericCharacterReference(string str) {}
     public static string FromNumericCharacterReferenceNullable(string str) {}
     public static string FromXhtmlEscapedString(string str) {}
     public static string FromXhtmlEscapedStringNullable(string str) {}
     public static string ToHtmlEscapedString(string str) {}
     public static string ToHtmlEscapedStringNullable(string str) {}
     public static string ToXhtmlEscapedString(string str) {}
     public static string ToXhtmlEscapedStringNullable(string str) {}
   }
 
   public class SIPrefixNumberFormatter :
     ICustomFormatter,
     IFormatProvider
   {
     protected SIPrefixNumberFormatter(CultureInfo cultureInfo, bool isReadOnly) {}
     public SIPrefixNumberFormatter() {}
     public SIPrefixNumberFormatter(CultureInfo cultureInfo) {}
 
     public string ByteUnit { get; set; }
     public string ByteUnitAbbreviation { get; set; }
     public static SIPrefixNumberFormatter CurrentInfo { get; }
     public static SIPrefixNumberFormatter InvaliantInfo { get; }
     public bool IsReadOnly { get; }
     public string PrefixUnitDelimiter { get; set; }
     public string ValuePrefixDelimiter { get; set; }
 
     public string Format(string format, object arg, IFormatProvider formatProvider) {}
     public object GetFormat(Type formatType) {}
   }
 
   public static class UriQuery {
     public static string JoinQueryParameters(IEnumerable<KeyValuePair<string, string>> queryParameters) {}
     public static IDictionary<string, string> SplitQueryParameters(string queryParameters) {}
     public static IDictionary<string, string> SplitQueryParameters(string queryParameters, IEqualityComparer<string> comparer) {}
   }
 }
 
 namespace Smdn.Formats.Csv {
   public class CsvReader : StreamReader {
     public CsvReader(Stream stream) {}
     public CsvReader(Stream stream, Encoding encoding) {}
     public CsvReader(StreamReader reader) {}
     public CsvReader(StreamReader reader, Encoding encoding) {}
     public CsvReader(string path) {}
     public CsvReader(string path, Encoding encoding) {}
 
     public char Delimiter { get; set; }
     public bool EscapeAlways { get; set; }
     public char Quotator { get; set; }
 
     public string[] ReadLine() {}
   }
 
   public class CsvWriter : StreamWriter {
     public CsvWriter(Stream stream) {}
     public CsvWriter(Stream stream, Encoding encoding) {}
     public CsvWriter(StreamWriter writer) {}
     public CsvWriter(StreamWriter writer, Encoding encoding) {}
     public CsvWriter(string path) {}
     public CsvWriter(string path, Encoding encoding) {}
 
     public char Delimiter { get; set; }
     public bool EscapeAlways { get; set; }
     public char Quotator { get; set; }
 
     public void WriteLine(params object[] columns) {}
     public void WriteLine(params string[] columns) {}
   }
 }
 
 namespace Smdn.Formats.Mime {
   public delegate string MimeEncodedWordConverter(Encoding charset, string encodingMethod, string encodedText);
 
   public enum ContentTransferEncodingMethod : int {
     Base64 = 3,
     Binary = 2,
     EightBit = 1,
     GZip64 = 6,
     QuotedPrintable = 4,
     SevenBit = 0,
     UUEncode = 5,
     Unknown = 7,
   }
 
   public enum MimeEncodingMethod : int {
     BEncoding = 1,
     Base64 = 1,
     None = 0,
     QEncoding = 2,
     QuotedPrintable = 2,
   }
 
   public static class ContentTransferEncoding {
     public const string HeaderName = "Content-Transfer-Encoding";
 
     public static BinaryReader CreateBinaryReader(Stream stream, ContentTransferEncodingMethod encoding) {}
     public static BinaryReader CreateBinaryReader(Stream stream, ContentTransferEncodingMethod encoding, Encoding charset) {}
     public static BinaryReader CreateBinaryReader(Stream stream, ContentTransferEncodingMethod encoding, Encoding charset, bool leaveStreamOpen) {}
     public static BinaryReader CreateBinaryReader(Stream stream, ContentTransferEncodingMethod encoding, bool leaveStreamOpen) {}
     public static BinaryReader CreateBinaryReader(Stream stream, string encoding) {}
     public static BinaryReader CreateBinaryReader(Stream stream, string encoding, bool leaveStreamOpen) {}
     public static Stream CreateDecodingStream(Stream stream, ContentTransferEncodingMethod encoding) {}
     public static Stream CreateDecodingStream(Stream stream, ContentTransferEncodingMethod encoding, bool leaveStreamOpen) {}
     public static Stream CreateDecodingStream(Stream stream, string encoding) {}
     public static Stream CreateDecodingStream(Stream stream, string encoding, bool leaveStreamOpen) {}
     public static StreamReader CreateTextReader(Stream stream, ContentTransferEncodingMethod encoding, Encoding charset) {}
     public static StreamReader CreateTextReader(Stream stream, ContentTransferEncodingMethod encoding, Encoding charset, bool leaveStreamOpen) {}
     public static StreamReader CreateTextReader(Stream stream, string encoding, string charset) {}
     public static StreamReader CreateTextReader(Stream stream, string encoding, string charset, bool leaveStreamOpen) {}
     public static ContentTransferEncodingMethod GetEncodingMethod(string encoding) {}
     public static ContentTransferEncodingMethod GetEncodingMethodThrowException(string encoding) {}
     public static string GetEncodingName(ContentTransferEncodingMethod method) {}
   }
 
   public static class MimeEncoding {
     public static string Decode(string str) {}
     public static string Decode(string str, EncodingSelectionCallback selectFallbackEncoding) {}
     public static string Decode(string str, EncodingSelectionCallback selectFallbackEncoding, MimeEncodedWordConverter decodeMalformedOrUnsupported) {}
     public static string Decode(string str, EncodingSelectionCallback selectFallbackEncoding, MimeEncodedWordConverter decodeMalformedOrUnsupported, out MimeEncodingMethod encoding, out Encoding charset) {}
     public static string Decode(string str, EncodingSelectionCallback selectFallbackEncoding, out MimeEncodingMethod encoding, out Encoding charset) {}
     public static string Decode(string str, out MimeEncodingMethod encoding, out Encoding charset) {}
     public static string DecodeNullable(string str) {}
     public static string DecodeNullable(string str, EncodingSelectionCallback selectFallbackEncoding) {}
     public static string DecodeNullable(string str, EncodingSelectionCallback selectFallbackEncoding, MimeEncodedWordConverter decodeMalformedOrUnsupported) {}
     public static string DecodeNullable(string str, EncodingSelectionCallback selectFallbackEncoding, MimeEncodedWordConverter decodeMalformedOrUnsupported, out MimeEncodingMethod encoding, out Encoding charset) {}
     public static string DecodeNullable(string str, EncodingSelectionCallback selectFallbackEncoding, out MimeEncodingMethod encoding, out Encoding charset) {}
     public static string DecodeNullable(string str, out MimeEncodingMethod encoding, out Encoding charset) {}
     public static string Encode(string str, MimeEncodingMethod encoding) {}
     public static string Encode(string str, MimeEncodingMethod encoding, Encoding charset) {}
     public static string Encode(string str, MimeEncodingMethod encoding, Encoding charset, int foldingLimit, int foldingOffset) {}
     public static string Encode(string str, MimeEncodingMethod encoding, Encoding charset, int foldingLimit, int foldingOffset, string foldingString) {}
     public static string Encode(string str, MimeEncodingMethod encoding, int foldingLimit, int foldingOffset) {}
     public static string Encode(string str, MimeEncodingMethod encoding, int foldingLimit, int foldingOffset, string foldingString) {}
   }
 
   public static class MimeUtils {
     public struct HeaderField {
       public int IndexOfDelimiter { get; }
       public ByteString Name { get; }
       public ByteString RawData { get; }
       public ByteString Value { get; }
     }
 
     public static IEnumerable<KeyValuePair<string, string>> ParseHeader(LineOrientedStream stream) {}
     public static IEnumerable<KeyValuePair<string, string>> ParseHeader(LineOrientedStream stream, bool keepWhitespaces) {}
     public static IEnumerable<KeyValuePair<string, string>> ParseHeader(Stream stream) {}
     public static IEnumerable<KeyValuePair<string, string>> ParseHeader(Stream stream, bool keepWhitespaces) {}
     public static IEnumerable<MimeUtils.HeaderField> ParseHeaderRaw(LineOrientedStream stream) {}
     public static string RemoveHeaderWhiteSpaceAndComment(string val) {}
   }
 }
 
 namespace Smdn.Formats.ModifiedBase64 {
   public class FromRFC2152ModifiedBase64Transform : ICryptoTransform {
     public FromRFC2152ModifiedBase64Transform() {}
     public FromRFC2152ModifiedBase64Transform(FromBase64TransformMode mode) {}
     public FromRFC2152ModifiedBase64Transform(bool ignoreWhiteSpaces) {}
 
     public bool CanReuseTransform { get; }
     public bool CanTransformMultipleBlocks { get; }
     public int InputBlockSize { get; }
     public int OutputBlockSize { get; }
 
     public void Dispose() {}
     public virtual int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public virtual byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 
   public sealed class FromRFC3501ModifiedBase64Transform : FromRFC2152ModifiedBase64Transform {
     public FromRFC3501ModifiedBase64Transform() {}
     public FromRFC3501ModifiedBase64Transform(FromBase64TransformMode mode) {}
     public FromRFC3501ModifiedBase64Transform(bool ignoreWhiteSpaces) {}
 
     public override int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public override byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 
   public static class ModifiedUTF7 {
     public static string Decode(string str) {}
     public static string Encode(string str) {}
   }
 
   public class ToRFC2152ModifiedBase64Transform : ICryptoTransform {
     public ToRFC2152ModifiedBase64Transform() {}
 
     public bool CanReuseTransform { get; }
     public bool CanTransformMultipleBlocks { get; }
     public int InputBlockSize { get; }
     public int OutputBlockSize { get; }
 
     public void Dispose() {}
     public virtual int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public virtual byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 
   public sealed class ToRFC3501ModifiedBase64Transform : ToRFC2152ModifiedBase64Transform {
     public ToRFC3501ModifiedBase64Transform() {}
 
     public override int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public override byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 }
 
 namespace Smdn.Formats.PercentEncodings {
   [Flags]
   public enum ToPercentEncodedTransformMode : int {
     EscapeSpaceToPlus = 0x00010000,
     ModeMask = 0x0000ffff,
     OptionMask = 0xffffffff,
     Rfc2396Data = 0x00000002,
     Rfc2396Uri = 0x00000001,
     Rfc3986Data = 0x00000008,
     Rfc3986Uri = 0x00000004,
     Rfc5092Path = 0x00000020,
     Rfc5092Uri = 0x00000010,
     UriEscapeDataString = 0x00000008,
     UriEscapeUriString = 0x00000004,
   }
 
   public sealed class FromPercentEncodedTransform : ICryptoTransform {
     public FromPercentEncodedTransform() {}
     public FromPercentEncodedTransform(bool decodePlusToSpace) {}
 
     public bool CanReuseTransform { get; }
     public bool CanTransformMultipleBlocks { get; }
     public int InputBlockSize { get; }
     public int OutputBlockSize { get; }
 
     public void Clear() {}
     void IDisposable.Dispose() {}
     public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 
   public static class PercentEncoding {
     public static byte[] Decode(string str) {}
     public static byte[] Decode(string str, bool decodePlusToSpace) {}
     public static byte[] Encode(string str, ToPercentEncodedTransformMode mode) {}
     public static byte[] Encode(string str, ToPercentEncodedTransformMode mode, Encoding encoding) {}
     public static string GetDecodedString(string str) {}
     public static string GetDecodedString(string str, Encoding encoding) {}
     public static string GetDecodedString(string str, Encoding encoding, bool decodePlusToSpace) {}
     public static string GetDecodedString(string str, bool decodePlusToSpace) {}
     public static string GetEncodedString(byte[] bytes, ToPercentEncodedTransformMode mode) {}
     public static string GetEncodedString(byte[] bytes, int offset, int count, ToPercentEncodedTransformMode mode) {}
     public static string GetEncodedString(string str, ToPercentEncodedTransformMode mode) {}
     public static string GetEncodedString(string str, ToPercentEncodedTransformMode mode, Encoding encoding) {}
   }
 
   public sealed class ToPercentEncodedTransform : ICryptoTransform {
     public ToPercentEncodedTransform(ToPercentEncodedTransformMode mode) {}
 
     public bool CanReuseTransform { get; }
     public bool CanTransformMultipleBlocks { get; }
     public int InputBlockSize { get; }
     public int OutputBlockSize { get; }
 
     public void Clear() {}
     void IDisposable.Dispose() {}
     public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 }
 
 namespace Smdn.Formats.QuotedPrintableEncodings {
   public enum FromQuotedPrintableTransformMode : int {
     ContentTransferEncoding = 0,
     MimeEncoding = 1,
   }
 
   public enum ToQuotedPrintableTransformMode : int {
     ContentTransferEncoding = 0,
     MimeEncoding = 1,
   }
 
   public sealed class FromQuotedPrintableTransform : ICryptoTransform {
     public FromQuotedPrintableTransform(FromQuotedPrintableTransformMode mode) {}
 
     public bool CanReuseTransform { get; }
     public bool CanTransformMultipleBlocks { get; }
     public int InputBlockSize { get; }
     public int OutputBlockSize { get; }
 
     public void Clear() {}
     void IDisposable.Dispose() {}
     public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 
   public static class QuotedPrintableEncoding {
     public static Stream CreateDecodingStream(Stream stream, bool leaveStreamOpen = false) {}
     public static Stream CreateEncodingStream(Stream stream, bool leaveStreamOpen = false) {}
     public static byte[] Decode(string str) {}
     public static byte[] Encode(string str) {}
     public static byte[] Encode(string str, Encoding encoding) {}
     public static string GetDecodedString(string str) {}
     public static string GetDecodedString(string str, Encoding encoding) {}
     public static string GetEncodedString(byte[] bytes) {}
     public static string GetEncodedString(byte[] bytes, int offset, int count) {}
     public static string GetEncodedString(string str) {}
     public static string GetEncodedString(string str, Encoding encoding) {}
   }
 
   public sealed class ToQuotedPrintableTransform : ICryptoTransform {
     public ToQuotedPrintableTransform(ToQuotedPrintableTransformMode mode) {}
 
     public bool CanReuseTransform { get; }
     public bool CanTransformMultipleBlocks { get; }
     public int InputBlockSize { get; }
     public int OutputBlockSize { get; }
 
     public void Clear() {}
     void IDisposable.Dispose() {}
     public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 }
 
 namespace Smdn.Formats.UUEncodings {
   public static class UUDecoder {
     public sealed class FileEntry : IDisposable {
       public FileEntry() {}
 
       public string FileName { get; }
       public uint Permissions { get; }
       public Stream Stream { get; }
 
       public void Dispose() {}
       public void Save() {}
       public void Save(string path) {}
     }
 
     public static IEnumerable<UUDecoder.FileEntry> ExtractFiles(Stream stream) {}
     public static void ExtractFiles(Stream stream, Action<UUDecoder.FileEntry> extractAction) {}
   }
 
   public class UUDecodingStream : Stream {
     public UUDecodingStream(Stream baseStream) {}
     public UUDecodingStream(Stream baseStream, bool leaveStreamOpen) {}
 
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     public bool EndOfFile { get; }
     public string FileName { get; }
     public override long Length { get; }
     public uint Permissions { get; }
     public override long Position { get; set; }
 
     public override void Close() {}
     public override void Flush() {}
     public override int Read(byte[] buffer, int offset, int count) {}
     public override int ReadByte() {}
     public override long Seek(long offset, SeekOrigin origin) {}
     public bool SeekToNextFile() {}
     public override void SetLength(long @value) {}
     public override void Write(byte[] buffer, int offset, int count) {}
   }
 
   public sealed class UUDecodingTransform : ICryptoTransform {
     public UUDecodingTransform() {}
 
     public bool CanReuseTransform { get; }
     public bool CanTransformMultipleBlocks { get; }
     public int InputBlockSize { get; }
     public int OutputBlockSize { get; }
 
     public void Clear() {}
     void IDisposable.Dispose() {}
     public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
     public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
   }
 }
 
 namespace Smdn.IO {
   public static class DirectoryInfoExtensions {
     public static IEnumerable<DirectoryInfo> GetDirectories(this DirectoryInfo directory, Predicate<DirectoryInfo> searchPattern) {}
     public static IEnumerable<DirectoryInfo> GetDirectories(this DirectoryInfo directory, SearchOption searchOption, Predicate<DirectoryInfo> searchPattern) {}
     public static IEnumerable<FileSystemInfo> GetFileSystemInfos(this DirectoryInfo directory, Predicate<FileSystemInfo> searchPattern) {}
     public static IEnumerable<FileSystemInfo> GetFileSystemInfos(this DirectoryInfo directory, SearchOption searchOption, Predicate<FileSystemInfo> searchPattern) {}
     public static IEnumerable<FileInfo> GetFiles(this DirectoryInfo directory, Predicate<FileInfo> searchPattern) {}
     public static IEnumerable<FileInfo> GetFiles(this DirectoryInfo directory, SearchOption searchOption, Predicate<FileInfo> searchPattern) {}
   }
 
   public static class DirectoryUtils {
     public static IEnumerable<string> GetDirectories(string directory, Predicate<string> searchPattern) {}
     public static IEnumerable<string> GetDirectories(string directory, SearchOption searchOption, Predicate<string> searchPattern) {}
     public static IEnumerable<string> GetFiles(string directory, Predicate<string> searchPattern) {}
     public static IEnumerable<string> GetFiles(string directory, SearchOption searchOption, Predicate<string> searchPattern) {}
   }
 
   public static class PathUtils {
     public static bool AreExtensionEqual(string path, string pathOrExtension) {}
     public static bool ArePathEqual(string pathX, string pathY) {}
     public static bool AreSameFile(string pathX, string pathY) {}
     public static string ChangeDirectoryName(string path, string newDirectoryName) {}
     public static string ChangeFileName(string path, string newFileName) {}
     public static bool ContainsShellEscapeChar(string path) {}
     public static bool ContainsShellEscapeChar(string path, Encoding encoding) {}
     public static bool ContainsShellPipeChar(string path) {}
     public static bool ContainsShellPipeChar(string path, Encoding encoding) {}
     public static bool ContainsShellSpecialChars(string path, Encoding encoding, params byte[] specialChars) {}
     public static string GetRelativePath(string basePath, string path) {}
     public static string RemoveInvalidFileNameChars(string path) {}
     public static string RemoveInvalidPathChars(string path) {}
     public static string RenameUnique(string file) {}
     public static string ReplaceInvalidFileNameChars(string path, StringExtensions.ReplaceCharEvaluator evaluator) {}
     public static string ReplaceInvalidFileNameChars(string path, string newValue) {}
     public static string ReplaceInvalidFileNameCharsWithBlanks(string path) {}
     public static string ReplaceInvalidPathChars(string path, StringExtensions.ReplaceCharEvaluator evaluator) {}
     public static string ReplaceInvalidPathChars(string path, string newValue) {}
     public static string ReplaceInvalidPathCharsWithBlanks(string path) {}
   }
 
   public static class StreamExtensions {
-    public static void CopyTo(this Stream stream, BinaryWriter writer) {}
-    public static void CopyTo(this Stream stream, BinaryWriter writer, int bufferSize) {}
-    public static byte[] ReadToEnd(this Stream stream) {}
-    public static byte[] ReadToEnd(this Stream stream, int initialCapacity) {}
-    public static byte[] ReadToEnd(this Stream stream, int readBufferSize, int initialCapacity) {}
+    public static void CopyTo(this Stream stream, BinaryWriter writer, int bufferSize = 10240) {}
+    public static Task CopyToAsync(this Stream stream, BinaryWriter writer, int bufferSize = 10240, CancellationToken cancellationToken = default) {}
+    public static byte[] ReadToEnd(this Stream stream, int readBufferSize = 4096, int initialCapacity = 4096) {}
+    public static Task<byte[]> ReadToEndAsync(this Stream stream, int readBufferSize = 4096, int initialCapacity = 4096, CancellationToken cancellationToken = default) {}
     public static void Write(this Stream stream, ArraySegment<byte> segment) {}
   }
 
   public static class TextReaderExtensions {
     public static string[] ReadAllLines(this TextReader reader) {}
+    public static Task<IReadOnlyList<string>> ReadAllLinesAsync(this TextReader reader) {}
     public static IEnumerable<string> ReadLines(this TextReader reader) {}
   }
 }
 
 namespace Smdn.IO.Binary {
   public class BigEndianBinaryReader : BinaryReader {
     protected BigEndianBinaryReader(Stream stream, bool leaveBaseStreamOpen, int storageSize) {}
     public BigEndianBinaryReader(Stream stream) {}
     public BigEndianBinaryReader(Stream stream, bool leaveBaseStreamOpen) {}
 
     public override short ReadInt16() {}
     public override int ReadInt32() {}
     public override long ReadInt64() {}
     public override ushort ReadUInt16() {}
     public override UInt24 ReadUInt24() {}
     public override uint ReadUInt32() {}
     public override UInt48 ReadUInt48() {}
     public override ulong ReadUInt64() {}
   }
 
   public class BigEndianBinaryWriter : BinaryWriter {
     protected BigEndianBinaryWriter(Stream stream, bool leaveBaseStreamOpen, int storageSize) {}
     public BigEndianBinaryWriter(Stream stream) {}
     public BigEndianBinaryWriter(Stream stream, bool leaveBaseStreamOpen) {}
 
     public override void Write(UInt24 @value) {}
     public override void Write(UInt48 @value) {}
     public override void Write(int @value) {}
     public override void Write(long @value) {}
     public override void Write(short @value) {}
     public override void Write(uint @value) {}
     public override void Write(ulong @value) {}
     public override void Write(ushort @value) {}
   }
 
   public static class BinaryConversion {
     public static int ByteSwap(int @value) {}
     public static long ByteSwap(long @value) {}
     public static short ByteSwap(short @value) {}
     public static uint ByteSwap(uint @value) {}
     public static ulong ByteSwap(ulong @value) {}
     public static ushort ByteSwap(ushort @value) {}
     public static byte[] GetBytes(UInt24 @value, Endianness endian) {}
     public static byte[] GetBytes(UInt48 @value, Endianness endian) {}
     public static byte[] GetBytes(int @value, Endianness endian) {}
     public static byte[] GetBytes(long @value, Endianness endian) {}
     public static byte[] GetBytes(short @value, Endianness endian) {}
     public static byte[] GetBytes(uint @value, Endianness endian) {}
     public static byte[] GetBytes(ulong @value, Endianness endian) {}
     public static byte[] GetBytes(ushort @value, Endianness endian) {}
     public static void GetBytes(UInt24 @value, Endianness endian, byte[] bytes, int startIndex) {}
     public static void GetBytes(UInt48 @value, Endianness endian, byte[] bytes, int startIndex) {}
     public static void GetBytes(int @value, Endianness endian, byte[] bytes, int startIndex) {}
     public static void GetBytes(long @value, Endianness endian, byte[] bytes, int startIndex) {}
     public static void GetBytes(short @value, Endianness endian, byte[] bytes, int startIndex) {}
     public static void GetBytes(uint @value, Endianness endian, byte[] bytes, int startIndex) {}
     public static void GetBytes(ulong @value, Endianness endian, byte[] bytes, int startIndex) {}
     public static void GetBytes(ushort @value, Endianness endian, byte[] bytes, int startIndex) {}
     public static byte[] GetBytesBE(UInt24 @value) {}
     public static byte[] GetBytesBE(UInt48 @value) {}
     public static byte[] GetBytesBE(int @value) {}
     public static byte[] GetBytesBE(long @value) {}
     public static byte[] GetBytesBE(short @value) {}
     public static byte[] GetBytesBE(uint @value) {}
     public static byte[] GetBytesBE(ulong @value) {}
     public static byte[] GetBytesBE(ushort @value) {}
     public static void GetBytesBE(UInt24 @value, byte[] bytes, int startIndex) {}
     public static void GetBytesBE(UInt48 @value, byte[] bytes, int startIndex) {}
     public static void GetBytesBE(int @value, byte[] bytes, int startIndex) {}
     public static void GetBytesBE(long @value, byte[] bytes, int startIndex) {}
     public static void GetBytesBE(short @value, byte[] bytes, int startIndex) {}
     public static void GetBytesBE(uint @value, byte[] bytes, int startIndex) {}
     public static void GetBytesBE(ulong @value, byte[] bytes, int startIndex) {}
     public static void GetBytesBE(ushort @value, byte[] bytes, int startIndex) {}
     public static byte[] GetBytesLE(UInt24 @value) {}
     public static byte[] GetBytesLE(UInt48 @value) {}
     public static byte[] GetBytesLE(int @value) {}
     public static byte[] GetBytesLE(long @value) {}
     public static byte[] GetBytesLE(short @value) {}
     public static byte[] GetBytesLE(uint @value) {}
     public static byte[] GetBytesLE(ulong @value) {}
     public static byte[] GetBytesLE(ushort @value) {}
     public static void GetBytesLE(UInt24 @value, byte[] bytes, int startIndex) {}
     public static void GetBytesLE(UInt48 @value, byte[] bytes, int startIndex) {}
     public static void GetBytesLE(int @value, byte[] bytes, int startIndex) {}
     public static void GetBytesLE(long @value, byte[] bytes, int startIndex) {}
     public static void GetBytesLE(short @value, byte[] bytes, int startIndex) {}
     public static void GetBytesLE(uint @value, byte[] bytes, int startIndex) {}
     public static void GetBytesLE(ulong @value, byte[] bytes, int startIndex) {}
     public static void GetBytesLE(ushort @value, byte[] bytes, int startIndex) {}
     public static short ToInt16(byte[] @value, int startIndex, Endianness endian) {}
     public static short ToInt16BE(byte[] @value, int startIndex) {}
     public static short ToInt16LE(byte[] @value, int startIndex) {}
     public static int ToInt32(byte[] @value, int startIndex, Endianness endian) {}
     public static int ToInt32BE(byte[] @value, int startIndex) {}
     public static int ToInt32LE(byte[] @value, int startIndex) {}
     public static long ToInt64(byte[] @value, int startIndex, Endianness endian) {}
     public static long ToInt64BE(byte[] @value, int startIndex) {}
     public static long ToInt64LE(byte[] @value, int startIndex) {}
     public static ushort ToUInt16(byte[] @value, int startIndex, Endianness endian) {}
     public static ushort ToUInt16BE(byte[] @value, int startIndex) {}
     public static ushort ToUInt16LE(byte[] @value, int startIndex) {}
     public static UInt24 ToUInt24(byte[] @value, int startIndex, Endianness endian) {}
     public static UInt24 ToUInt24BE(byte[] @value, int startIndex) {}
     public static UInt24 ToUInt24LE(byte[] @value, int startIndex) {}
     public static uint ToUInt32(byte[] @value, int startIndex, Endianness endian) {}
     public static uint ToUInt32BE(byte[] @value, int startIndex) {}
     public static uint ToUInt32LE(byte[] @value, int startIndex) {}
     public static UInt48 ToUInt48(byte[] @value, int startIndex, Endianness endian) {}
     public static UInt48 ToUInt48BE(byte[] @value, int startIndex) {}
     public static UInt48 ToUInt48LE(byte[] @value, int startIndex) {}
     public static ulong ToUInt64(byte[] @value, int startIndex, Endianness endian) {}
     public static ulong ToUInt64BE(byte[] @value, int startIndex) {}
     public static ulong ToUInt64LE(byte[] @value, int startIndex) {}
   }
 
   public class BinaryReader : BinaryReaderBase {
     protected readonly byte[] Storage;
 
     protected BinaryReader(Stream baseStream, Endianness endianness, bool leaveBaseStreamOpen) {}
     protected BinaryReader(Stream baseStream, Endianness endianness, bool leaveBaseStreamOpen, int storageSize) {}
     public BinaryReader(Stream stream) {}
     public BinaryReader(Stream stream, bool leaveBaseStreamOpen) {}
 
     public Endianness Endianness { get; }
 
     public override byte ReadByte() {}
     public virtual FourCC ReadFourCC() {}
     public override short ReadInt16() {}
     public override int ReadInt32() {}
     public override long ReadInt64() {}
     public override sbyte ReadSByte() {}
     public override ushort ReadUInt16() {}
     public virtual UInt24 ReadUInt24() {}
     public override uint ReadUInt32() {}
     public virtual UInt48 ReadUInt48() {}
     public override ulong ReadUInt64() {}
   }
 
   public abstract class BinaryReaderBase : IDisposable {
     protected BinaryReaderBase(Stream baseStream, bool leaveBaseStreamOpen) {}
 
     public Stream BaseStream { get; }
     protected bool Disposed { get; }
     public virtual bool EndOfStream { get; }
     public bool LeaveBaseStreamOpen { get; }
 
     protected void CheckDisposed() {}
     public virtual void Close() {}
     protected virtual void Dispose(bool disposing) {}
     public virtual byte ReadByte() {}
     protected int ReadBytes(byte[] buffer, int index, int count, bool readExactBytes) {}
     public byte[] ReadBytes(int count) {}
     public byte[] ReadBytes(long count) {}
     public int ReadBytes(byte[] buffer, int index, int count) {}
     protected virtual int ReadBytesUnchecked(byte[] buffer, int index, int count, bool readExactBytes) {}
     public byte[] ReadExactBytes(int count) {}
     public byte[] ReadExactBytes(long count) {}
     public void ReadExactBytes(byte[] buffer, int index, int count) {}
     public abstract short ReadInt16();
     public abstract int ReadInt32();
     public abstract long ReadInt64();
     public virtual sbyte ReadSByte() {}
     public virtual byte[] ReadToEnd() {}
     public virtual ushort ReadUInt16() {}
     public virtual uint ReadUInt32() {}
     public virtual ulong ReadUInt64() {}
     void IDisposable.Dispose() {}
   }
 
   public class BinaryWriter : BinaryWriterBase {
     protected byte[] Storage;
 
     protected BinaryWriter(Stream baseStream, Endianness endianness, bool leaveBaseStreamOpen) {}
     protected BinaryWriter(Stream baseStream, Endianness endianness, bool leaveBaseStreamOpen, int storageSize) {}
     public BinaryWriter(Stream stream) {}
     public BinaryWriter(Stream stream, bool leaveBaseStreamOpen) {}
 
     public Endianness Endianness { get; }
 
     public override void Write(byte @value) {}
     public override void Write(int @value) {}
     public override void Write(long @value) {}
     public override void Write(sbyte @value) {}
     public override void Write(short @value) {}
     public override void Write(uint @value) {}
     public override void Write(ulong @value) {}
     public override void Write(ushort @value) {}
     public virtual void Write(FourCC @value) {}
     public virtual void Write(UInt24 @value) {}
     public virtual void Write(UInt48 @value) {}
   }
 
   public abstract class BinaryWriterBase : IDisposable {
     protected BinaryWriterBase(Stream baseStream, bool leaveBaseStreamOpen) {}
 
     public Stream BaseStream { get; }
     protected bool Disposed { get; }
     public bool LeaveBaseStreamOpen { get; }
 
     protected void CheckDisposed() {}
     public virtual void Close() {}
     protected virtual void Dispose(bool disposing) {}
     public void Flush() {}
     void IDisposable.Dispose() {}
     public abstract void Write(int @value);
     public abstract void Write(long @value);
     public abstract void Write(short @value);
     public virtual void Write(byte @value) {}
     public virtual void Write(sbyte @value) {}
     public virtual void Write(uint @value) {}
     public virtual void Write(ulong @value) {}
     public virtual void Write(ushort @value) {}
     public void Write(ArraySegment<byte> @value) {}
     public void Write(byte[] buffer) {}
     public void Write(byte[] buffer, int index, int count) {}
     protected void WriteUnchecked(byte[] buffer, int index, int count) {}
     public void WriteZero(int count) {}
     public void WriteZero(long count) {}
   }
 
   public class LittleEndianBinaryReader : BinaryReader {
     protected LittleEndianBinaryReader(Stream stream, bool leaveBaseStreamOpen, int storageSize) {}
     public LittleEndianBinaryReader(Stream stream) {}
     public LittleEndianBinaryReader(Stream stream, bool leaveBaseStreamOpen) {}
 
     public override short ReadInt16() {}
     public override int ReadInt32() {}
     public override long ReadInt64() {}
     public override ushort ReadUInt16() {}
     public override UInt24 ReadUInt24() {}
     public override uint ReadUInt32() {}
     public override UInt48 ReadUInt48() {}
     public override ulong ReadUInt64() {}
   }
 
   public class LittleEndianBinaryWriter : BinaryWriter {
     protected LittleEndianBinaryWriter(Stream stream, bool leaveBaseStreamOpen, int storageSize) {}
     public LittleEndianBinaryWriter(Stream stream) {}
     public LittleEndianBinaryWriter(Stream stream, bool leaveBaseStreamOpen) {}
 
     public override void Write(UInt24 @value) {}
     public override void Write(UInt48 @value) {}
     public override void Write(int @value) {}
     public override void Write(long @value) {}
     public override void Write(short @value) {}
     public override void Write(uint @value) {}
     public override void Write(ulong @value) {}
     public override void Write(ushort @value) {}
   }
 }
 
 namespace Smdn.IO.Streams {
   public sealed class ChunkedMemoryStream : Stream {
     public delegate ChunkedMemoryStream.Chunk Allocator(int chunkSize);
 
     public abstract class Chunk : IDisposable {
       public byte[] Data;
 
       protected Chunk() {}
 
       public abstract void Dispose();
     }
 
     public static readonly int DefaultChunkSize = 40960;
 
     public ChunkedMemoryStream() {}
     public ChunkedMemoryStream(ChunkedMemoryStream.Allocator allocator) {}
     public ChunkedMemoryStream(int chunkSize) {}
     public ChunkedMemoryStream(int chunkSize, ChunkedMemoryStream.Allocator allocator) {}
 
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     public int ChunkSize { get; }
     public override long Length { get; }
     public override long Position { get; set; }
 
     public override void Close() {}
     public override void Flush() {}
     public override int Read(byte[] buffer, int offset, int count) {}
     public override int ReadByte() {}
     public override long Seek(long offset, SeekOrigin origin) {}
     public override void SetLength(long @value) {}
     public byte[] ToArray() {}
     public override void Write(byte[] buffer, int offset, int count) {}
     public override void WriteByte(byte @value) {}
   }
 
   public class ExtendStream : ExtendStreamBase {
     public ExtendStream(Stream innerStream, Stream prependStream, Stream appendStream) {}
     public ExtendStream(Stream innerStream, Stream prependStream, Stream appendStream, bool leaveInnerStreamOpen) {}
     public ExtendStream(Stream innerStream, byte[] prependData, byte[] appendData) {}
     public ExtendStream(Stream innerStream, byte[] prependData, byte[] appendData, bool leaveInnerStreamOpen) {}
 
     protected override bool CanSeekAppendedData { get; }
     protected override bool CanSeekPrependedData { get; }
 
     public override void Close() {}
     protected override void ReadAppendedData(byte[] buffer, int offset, int count) {}
     protected override void ReadPrependedData(byte[] buffer, int offset, int count) {}
     protected override void SetAppendedDataPosition(long position) {}
     protected override void SetPrependedDataPosition(long position) {}
   }
 
   public abstract class ExtendStreamBase : Stream {
     protected enum Range : int {
       Appended = 2,
       EndOfStream = 3,
       InnerStream = 1,
       Prepended = 0,
     }
 
     protected ExtendStreamBase(Stream innerStream, long prependLength, long appendLength, bool leaveInnerStreamOpen) {}
 
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     protected abstract bool CanSeekAppendedData { get; }
     protected abstract bool CanSeekPrependedData { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     protected ExtendStreamBase.Range DataRange { get; }
     public Stream InnerStream { get; }
     public bool LeaveInnerStreamOpen { get; }
     public override long Length { get; }
     public override long Position { get; set; }
 
     public override void Close() {}
     public override void Flush() {}
     public override int Read(byte[] buffer, int offset, int count) {}
     protected abstract void ReadAppendedData(byte[] buffer, int offset, int count);
     protected abstract void ReadPrependedData(byte[] buffer, int offset, int count);
     public override long Seek(long offset, SeekOrigin origin) {}
     protected abstract void SetAppendedDataPosition(long position);
     public override void SetLength(long @value) {}
     protected abstract void SetPrependedDataPosition(long position);
     public override void Write(byte[] buffer, int offset, int count) {}
   }
 
   public class NonClosingStream : Stream {
     public NonClosingStream(Stream innerStream) {}
     public NonClosingStream(Stream innerStream, bool writable) {}
 
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     public Stream InnerStream { get; }
     public override long Length { get; }
     public override long Position { get; set; }
 
     public override void Close() {}
     public override void Flush() {}
     public override int Read(byte[] buffer, 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 class PartialStream :
     Stream,
     ICloneable
   {
     public PartialStream(Stream innerStream, long offset) {}
     public PartialStream(Stream innerStream, long offset, bool @readonly, bool leaveInnerStreamOpen) {}
     public PartialStream(Stream innerStream, long offset, bool @readonly, bool leaveInnerStreamOpen, bool seekToBegin) {}
     public PartialStream(Stream innerStream, long offset, bool leaveInnerStreamOpen) {}
     public PartialStream(Stream innerStream, long offset, long length) {}
     public PartialStream(Stream innerStream, long offset, long length, bool @readonly, bool leaveInnerStreamOpen) {}
     public PartialStream(Stream innerStream, long offset, long length, bool @readonly, bool leaveInnerStreamOpen, bool seekToBegin) {}
     public PartialStream(Stream innerStream, long offset, long length, bool leaveInnerStreamOpen) {}
 
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     public Stream InnerStream { get; }
     public bool LeaveInnerStreamOpen { get; }
     public override long Length { get; }
     public override long Position { get; set; }
 
     public PartialStream Clone() {}
     public override void Close() {}
     public static PartialStream CreateNonNested(Stream innerOrPartialStream, long length) {}
     public static PartialStream CreateNonNested(Stream innerOrPartialStream, long length, bool seekToBegin) {}
     public static PartialStream CreateNonNested(Stream innerOrPartialStream, long offset, long length) {}
     public static PartialStream CreateNonNested(Stream innerOrPartialStream, long offset, long length, bool seekToBegin) {}
     public override void Flush() {}
     protected long GetRemainderLength() {}
     public override int Read(byte[] buffer, int offset, int count) {}
     public override int ReadByte() {}
     public override long Seek(long offset, SeekOrigin origin) {}
     public override void SetLength(long @value) {}
     object ICloneable.Clone() {}
     public override void Write(byte[] buffer, int offset, int count) {}
   }
 }
 
 namespace Smdn.IO.Streams.Caching {
   public abstract class CachedStreamBase : Stream {
     protected CachedStreamBase(Stream innerStream, int blockSize, bool leaveInnerStreamOpen) {}
 
     public int BlockSize { get; }
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     public Stream InnerStream { get; }
     public bool LeaveInnerStreamOpen { get; }
     public override long Length { get; }
     public override long Position { get; set; }
 
     public override void Close() {}
     public override void Flush() {}
     protected abstract byte[] GetBlock(long blockIndex);
     public override int Read(byte[] buffer, int offset, int count) {}
     protected byte[] ReadBlock(long blockIndex) {}
     public override int ReadByte() {}
     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 override void WriteByte(byte @value) {}
   }
 
   public sealed class NonPersistentCachedStream : CachedStreamBase {
     public NonPersistentCachedStream(Stream innerStream) {}
     public NonPersistentCachedStream(Stream innerStream, bool leaveInnerStreamOpen) {}
     public NonPersistentCachedStream(Stream innerStream, int blockSize) {}
     public NonPersistentCachedStream(Stream innerStream, int blockSize, bool leaveInnerStreamOpen) {}
 
     public override void Close() {}
     protected override byte[] GetBlock(long blockIndex) {}
   }
 
   public sealed class PersistentCachedStream : CachedStreamBase {
     public PersistentCachedStream(Stream innerStream) {}
     public PersistentCachedStream(Stream innerStream, bool leaveInnerStreamOpen) {}
     public PersistentCachedStream(Stream innerStream, int blockSize) {}
     public PersistentCachedStream(Stream innerStream, int blockSize, bool leaveInnerStreamOpen) {}
 
     public override void Close() {}
     protected override byte[] GetBlock(long blockIndex) {}
   }
 }
 
 namespace Smdn.IO.Streams.LineOriented {
   public class LineOrientedStream : Stream {
     protected static readonly int DefaultBufferSize = 1024;
     protected static readonly bool DefaultLeaveStreamOpen = false;
     protected static readonly int MinimumBufferSize = 8;
 
     protected LineOrientedStream(Stream stream, byte[] newLine, bool strictEOL, int bufferSize, bool leaveStreamOpen) {}
 
     public int BufferSize { get; }
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     public virtual Stream InnerStream { get; }
     public override long Length { get; }
     public IReadOnlyList<byte> NewLine { get; }
     public override long Position { get; set; }
 
     protected override void Dispose(bool disposing) {}
     public override void Flush() {}
     public long Read(Stream targetStream, long length) {}
     public override int Read(byte[] buffer, int offset, int count) {}
     public override int ReadByte() {}
     public byte[] ReadLine() {}
     public byte[] ReadLine(bool keepEOL) {}
     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 class LooseLineOrientedStream : LineOrientedStream {
     public LooseLineOrientedStream(Stream stream) {}
     public LooseLineOrientedStream(Stream stream, bool leaveStreamOpen) {}
     public LooseLineOrientedStream(Stream stream, int bufferSize) {}
     public LooseLineOrientedStream(Stream stream, int bufferSize, bool leaveStreamOpen) {}
   }
 
   public class StrictLineOrientedStream : LineOrientedStream {
     public StrictLineOrientedStream(Stream stream) {}
     public StrictLineOrientedStream(Stream stream, bool leaveStreamOpen) {}
     public StrictLineOrientedStream(Stream stream, byte[] newLine) {}
     public StrictLineOrientedStream(Stream stream, byte[] newLine, bool leaveStreamOpen) {}
     public StrictLineOrientedStream(Stream stream, byte[] newLine, int bufferSize) {}
     public StrictLineOrientedStream(Stream stream, byte[] newLine, int bufferSize, bool leaveStreamOpen) {}
     public StrictLineOrientedStream(Stream stream, int bufferSize) {}
     public StrictLineOrientedStream(Stream stream, int bufferSize, bool leaveStreamOpen) {}
   }
 }
 
 namespace Smdn.OperatingSystem {
   public static class EnvironmentVariable {
     public static string CombineEnvironmentVariables(IDictionary<string, string> variables) {}
     public static Dictionary<string, string> ParseEnvironmentVariables(string variables) {}
     public static Dictionary<string, string> ParseEnvironmentVariables(string variables, bool throwIfInvalid) {}
   }
 
   public class PipeOutStream : Stream {
     public PipeOutStream(ProcessStartInfo startInfo) {}
     public PipeOutStream(ProcessStartInfo startInfo, DataReceivedEventHandler onErrorDataReceived) {}
     public PipeOutStream(ProcessStartInfo startInfo, DataReceivedEventHandler onOutputDataReceived, DataReceivedEventHandler onErrorDataReceived) {}
 
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     public override long Length { get; }
     public override long Position { get; set; }
     public Process Process { get; }
     public ProcessStartInfo StartInfo { get; }
     public int WaitForExitTimeout { get; }
 
     public override void Close() {}
     public override void Flush() {}
     public override int Read(byte[] buffer, 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 override void WriteByte(byte @value) {}
   }
 
   public static class Shell {
     public static ProcessStartInfo CreateProcessStartInfo(string command, params string[] arguments) {}
     public static ProcessStartInfo CreateProcessStartInfo(string command, string arguments) {}
     public static int Execute(string command, out string stdout) {}
     public static int Execute(string command, out string stdout, out string stderr) {}
     public static string Execute(string command) {}
   }
 
   public class ShellString :
     ICloneable,
     IEquatable<ShellString>,
     IEquatable<string>
   {
     public ShellString(string raw) {}
 
     public string Expanded { get; }
     public bool IsEmpty { get; }
     public string Raw { get; set; }
 
     public ShellString Clone() {}
     public bool Equals(ShellString other) {}
     public bool Equals(string other) {}
     public override bool Equals(object obj) {}
     public static string Expand(ShellString str) {}
     public override int GetHashCode() {}
     public static bool IsNullOrEmpty(ShellString str) {}
     object ICloneable.Clone() {}
     public override string ToString() {}
     public static bool operator == (ShellString x, ShellString y) {}
     public static explicit operator string(ShellString str) {}
     public static implicit operator ShellString(string str) {}
     public static bool operator != (ShellString x, ShellString y) {}
   }
 }
 
 namespace Smdn.Security.Cryptography {
   public static class ICryptoTransformExtensions {
     public static byte[] TransformBytes(this ICryptoTransform transform, byte[] inputBuffer) {}
     public static byte[] TransformBytes(this ICryptoTransform transform, byte[] inputBuffer, int inputOffset, int inputCount) {}
     public static string TransformStringFrom(this ICryptoTransform transform, string str, Encoding encoding) {}
     public static string TransformStringTo(this ICryptoTransform transform, string str, Encoding encoding) {}
   }
 }
 
 namespace Smdn.Text {
   public static class Ascii {
     public static class Chars {
       public const char Ampersand = '&';
       public const char CR = '\u000D';
       public const string CRLF = "\u000D\u000A";
       public const char Comma = ',';
       public const char DQuote = '"';
       public const char GreaterThan = '>';
       public const char HT = '\u0009';
       public const char LF = '\u000A';
       public const char LessThan = '<';
       public const char NUL = '\u0000';
       public const char Quote = '\'';
       public const char SP = ' ';
 
       public static IReadOnlyList<char> LowerCaseHexChars { get; }
       public static IReadOnlyList<char> UpperCaseHexChars { get; }
 
       [Obsolete("use LowerCaseHexChars instead")]
       public static char[] GetLowerCaseHexChars() {}
       [Obsolete("use UpperCaseHexChars instead")]
       public static char[] GetUpperCaseHexChars() {}
     }
 
     public static class Hexadecimals {
       public static byte[] ToByteArray(string hexString) {}
       public static byte[] ToByteArrayFromLowerString(string lowerCasedString) {}
       public static byte[] ToByteArrayFromUpperString(string upperCasedString) {}
       public static byte[] ToLowerByteArray(byte[] bytes) {}
       public static string ToLowerString(byte[] bytes) {}
       public static byte[] ToUpperByteArray(byte[] bytes) {}
       public static string ToUpperString(byte[] bytes) {}
     }
 
     public static class Octets {
       public const byte CR = 13;
       public const byte HT = 9;
       public const byte LF = 10;
       public const byte NUL = byte.MinValue;
       public const byte SP = 32;
 
       public static IReadOnlyList<byte> CRLF { get; }
       public static IReadOnlyList<byte> LowerCaseHexOctets { get; }
       public static IReadOnlyList<byte> ToLowerCaseAsciiTable { get; }
       public static IReadOnlyList<byte> ToUpperCaseAsciiTable { get; }
       public static IReadOnlyList<byte> UpperCaseHexOctets { get; }
 
       [Obsolete("use CRLF instead")]
       public static byte[] GetCRLF() {}
       [Obsolete("use LowerCaseHexOctets instead")]
       public static byte[] GetLowerCaseHexOctets() {}
       [Obsolete("use ToLowerCaseAsciiTable instead")]
       public static byte[] GetToLowerCaseAsciiTable() {}
       [Obsolete("use ToUpperCaseAsciiTable instead")]
       public static byte[] GetToUpperCaseAsciiTable() {}
       [Obsolete("use UpperCaseHexOctets instead")]
       public static byte[] GetUpperCaseHexOctets() {}
       public static bool IsDecimalNumber(byte b) {}
     }
   }
 
   [Serializable]
   public class ByteString :
     IEquatable<ArraySegment<byte>>,
     IEquatable<ByteString>,
     IEquatable<byte[]>,
     IEquatable<string>,
     ISerializable
   {
     protected ByteString(SerializationInfo info, StreamingContext context) {}
     public ByteString(ArraySegment<byte> segment, bool asMutable) {}
     public ByteString(string @value, bool asMutable) {}
 
     public byte this[int index] { get; set; }
     public bool IsEmpty { get; }
     public bool IsMutable { get; }
     public int Length { get; }
     public ArraySegment<byte> Segment { get; }
 
     public static ByteString Concat(bool asMutable, params ByteString[] values) {}
     public static ByteString Concat(params ByteString[] values) {}
     public static ByteString ConcatImmutable(params ByteString[] values) {}
     public static ByteString ConcatMutable(params ByteString[] values) {}
     public bool Contains(ByteString @value) {}
     public bool Contains(byte[] @value) {}
     public void CopyTo(byte[] dest) {}
     public void CopyTo(byte[] dest, int destOffset) {}
     public void CopyTo(byte[] dest, int destOffset, int count) {}
     public void CopyTo(int startIndex, byte[] dest) {}
     public void CopyTo(int startIndex, byte[] dest, int destOffset) {}
     public void CopyTo(int startIndex, byte[] dest, int destOffset, int count) {}
     public static ByteString Create(bool asMutable, byte[] @value, int offset) {}
     public static ByteString Create(bool asMutable, byte[] @value, int offset, int count) {}
     public static ByteString Create(bool asMutable, params byte[] @value) {}
     public static ByteString CreateEmpty() {}
     public static ByteString CreateImmutable(byte[] @value, int offset) {}
     public static ByteString CreateImmutable(byte[] @value, int offset, int count) {}
     public static ByteString CreateImmutable(params byte[] @value) {}
     public static ByteString CreateImmutable(string str) {}
     public static ByteString CreateImmutable(string str, int startIndex, int count) {}
     public static ByteString CreateMutable(byte[] @value, int offset) {}
     public static ByteString CreateMutable(byte[] @value, int offset, int count) {}
     public static ByteString CreateMutable(params byte[] @value) {}
     public static ByteString CreateMutable(string str) {}
     public static ByteString CreateMutable(string str, int startIndex, int count) {}
     public bool EndsWith(ArraySegment<byte> @value) {}
     public bool EndsWith(ByteString @value) {}
     public bool EndsWith(byte[] @value) {}
     public bool EndsWith(string @value) {}
     public bool Equals(ArraySegment<byte> other) {}
     public bool Equals(ByteString other) {}
     public bool Equals(byte[] other) {}
     public bool Equals(string other) {}
     public override bool Equals(object obj) {}
     public bool EqualsIgnoreCase(ByteString other) {}
     public bool EqualsIgnoreCase(string other) {}
     public override int GetHashCode() {}
     public void GetObjectData(SerializationInfo info, StreamingContext context) {}
     public IEnumerable<ByteString> GetSplittedSubstrings(byte delimiter) {}
     public IEnumerable<ByteString> GetSplittedSubstrings(char delimiter) {}
     public ArraySegment<byte> GetSubSegment(int startIndex) {}
     public ArraySegment<byte> GetSubSegment(int startIndex, int count) {}
     public int IndexOf(ArraySegment<byte> @value) {}
     public int IndexOf(ArraySegment<byte> @value, int startIndex) {}
     public int IndexOf(ByteString @value) {}
     public int IndexOf(ByteString @value, int startIndex) {}
     public int IndexOf(byte @value) {}
     public int IndexOf(byte @value, int startIndex) {}
     public int IndexOf(byte[] @value) {}
     public int IndexOf(byte[] @value, int startIndex) {}
     public int IndexOf(char @value) {}
     public int IndexOf(char @value, int startIndex) {}
     public int IndexOf(string @value) {}
     public int IndexOf(string @value, int startIndex) {}
     public int IndexOfIgnoreCase(ArraySegment<byte> @value) {}
     public int IndexOfIgnoreCase(ArraySegment<byte> @value, int startIndex) {}
     public int IndexOfIgnoreCase(ByteString @value) {}
     public int IndexOfIgnoreCase(ByteString @value, int startIndex) {}
     public int IndexOfIgnoreCase(byte[] @value) {}
     public int IndexOfIgnoreCase(byte[] @value, int startIndex) {}
     public int IndexOfNot(byte @value) {}
     public int IndexOfNot(byte @value, int startIndex) {}
     public int IndexOfNot(char @value) {}
     public int IndexOfNot(char @value, int startIndex) {}
     public static bool IsNullOrEmpty(ByteString str) {}
     public bool IsPrefixOf(ArraySegment<byte> @value) {}
     public bool IsPrefixOf(ByteString @value) {}
     public bool IsPrefixOf(byte[] @value) {}
     public static bool IsTerminatedByCRLF(ByteString str) {}
     public ByteString[] Split(byte delimiter) {}
     public ByteString[] Split(char delimiter) {}
     public bool StartsWith(ArraySegment<byte> @value) {}
     public bool StartsWith(ByteString @value) {}
     public bool StartsWith(byte[] @value) {}
     public bool StartsWith(string @value) {}
     public bool StartsWithIgnoreCase(ArraySegment<byte> @value) {}
     public bool StartsWithIgnoreCase(ByteString @value) {}
     public bool StartsWithIgnoreCase(byte[] @value) {}
     public ByteString Substring(int startIndex) {}
     public ByteString Substring(int startIndex, int count) {}
     public byte[] ToArray() {}
     public byte[] ToArray(int startIndex) {}
     public byte[] ToArray(int startIndex, int count) {}
     public static byte[] ToByteArray(string @value) {}
     public static byte[] ToByteArray(string @value, int startIndex, int count) {}
     public ByteString ToLower() {}
     public override string ToString() {}
     public string ToString(Encoding encoding) {}
     public string ToString(Encoding encoding, int startIndex) {}
     public string ToString(Encoding encoding, int startIndex, int count) {}
     public string ToString(int startIndex) {}
     public string ToString(int startIndex, int count) {}
     public uint ToUInt32() {}
     public ulong ToUInt64() {}
     public ByteString ToUpper() {}
     public ByteString Trim() {}
     public ByteString TrimEnd() {}
     public ByteString TrimStart() {}
     public static ByteString operator + (ByteString x, ByteString y) {}
     public static bool operator == (ByteString x, ByteString y) {}
     public static bool operator != (ByteString x, ByteString y) {}
     public static ByteString operator * (ByteString x, int y) {}
   }
 
   public class ByteStringBuilder {
     public ByteStringBuilder() {}
     public ByteStringBuilder(int capacity) {}
     public ByteStringBuilder(int capacity, int maxCapacity) {}
 
     public byte this[int index] { get; set; }
     public int Capacity { get; }
     public int Length { get; set; }
     public int MaxCapacity { get; }
 
     public ByteStringBuilder Append(ArraySegment<byte> segment) {}
     public ByteStringBuilder Append(ByteString str) {}
     public ByteStringBuilder Append(ByteString str, int startIndex, int count) {}
     public ByteStringBuilder Append(byte b) {}
     public ByteStringBuilder Append(byte[] str) {}
     public ByteStringBuilder Append(byte[] str, int startIndex, int count) {}
     public ByteStringBuilder Append(string str) {}
     public ArraySegment<byte> GetSegment() {}
     public ArraySegment<byte> GetSegment(int offset, int count) {}
     public byte[] ToByteArray() {}
     public ByteString ToByteString(bool asMutable) {}
     public override string ToString() {}
   }
 
   public static class StringConversion {
     public static bool? ToBooleanNullable(string val) {}
     public static TEnum ToEnum<TEnum>(string @value) where TEnum : Enum {}
     public static TEnum ToEnum<TEnum>(string @value, bool ignoreCase) where TEnum : Enum {}
     public static TEnum ToEnumIgnoreCase<TEnum>(string @value) where TEnum : Enum {}
     public static TEnum? ToEnumNullable<TEnum>(string val) where TEnum : struct, Enum {}
     public static int? ToInt32Nullable(string val) {}
     public static string ToJoinedString<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> pairs) {}
     public static string ToString(Type type, IEnumerable<(string name, object value)> nameAndValuePairs) {}
     public static string ToString(Uri val) {}
     public static string ToStringNullable(Uri val) {}
     public static string ToStringNullable(bool? val) {}
     public static string ToStringNullable(int? val) {}
     public static Uri ToUri(string val) {}
     public static Uri ToUriNullable(string val) {}
   }
 }
 
 namespace Smdn.Text.Encodings {
   public delegate Encoding EncodingSelectionCallback(string name);
 
   [Serializable]
   public class EncodingNotSupportedException : NotSupportedException {
     protected EncodingNotSupportedException(SerializationInfo info, StreamingContext context) {}
     public EncodingNotSupportedException() {}
     public EncodingNotSupportedException(string encodingName) {}
     public EncodingNotSupportedException(string encodingName, Exception innerException) {}
     public EncodingNotSupportedException(string encodingName, string message) {}
     public EncodingNotSupportedException(string encodingName, string message, Exception innerException) {}
 
     public string EncodingName { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   public static class EncodingUtils {
     public static Encoding GetEncoding(string name) {}
     public static Encoding GetEncoding(string name, EncodingSelectionCallback selectFallbackEncoding) {}
     public static Encoding GetEncodingThrowException(string name) {}
     public static Encoding GetEncodingThrowException(string name, EncodingSelectionCallback selectFallbackEncoding) {}
   }
 
   public class OctetEncoding : Encoding {
     public static readonly Encoding EightBits; // = "Smdn.Text.Encodings.OctetEncoding"
     public static readonly Encoding SevenBits; // = "Smdn.Text.Encodings.OctetEncoding"
 
     public OctetEncoding(int bits) {}
     public OctetEncoding(int bits, EncoderFallback encoderFallback, DecoderFallback decoderFallback) {}
 
     public override int GetByteCount(char[] chars, int index, int count) {}
     public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) {}
     public override int GetCharCount(byte[] bytes, int index, int count) {}
     public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) {}
     public override int GetMaxByteCount(int charCount) {}
     public override int GetMaxCharCount(int byteCount) {}
   }
 }
 
 namespace Smdn.Text.RegularExpressions {
   public static class RegexExtensions {
     public static bool IsMatch(this Regex regex, string input, out Match match) {}
   }
 }