Smdn.dllは各種ユーティリティ・フレームワーク間の差異吸収等を目的とした基盤ライブラリです。 現在、本ライブラリは単独でのリリースはしていません。 下記ライブラリに同梱されているものをご利用ください。

不具合の報告、ライブラリに対する要望や提案、使い方の質問などは掲示板へどうぞ。

Smdn.Core.*.dllの統合

Smdn.Core.Standards.dll, Smdn.Core.BinaryFormats.dll, Smdn.Core.Miscellaneous.dllは、Smdn.dllへ統合しました(一部の型を除く)。 左記以外のアセンブリからも一部統合した型があります。

上記アセンブリの型を直接使用している場合はコードの修正を行う必要があります。 下記バージョンのライブラリを使用しているコードについては、恐れ入りますが後述の対応表に従い修正を行ってください。

ライブラリ 対象バージョン
Smdn.Net.Imap4.Client v1.14以前 および v1.1x系のバージョン
Smdn.Net.Pop3.Client v1.26以前 および v1.2x系のバージョン
Smdn.Formats.Mime v0.39以前 および v0.4x系のバージョン
Smdn.Security.Authentication.Sasl v1.00以前 および v1.0x系のバージョン

Smdn.Core.*.dllの統合に伴う変更の詳細は次のとおりです。 コード形式でのAPI一覧および差分は§.APIリストをご覧ください。

凡例
➡️移動 名前空間の移動のみ。 インターフェイス変更は基本的に無し。
↪️リネーム 名前空間の移動 and/or 型名の変更。 型名以外のインターフェイス変更は基本的に無し。
♻️型を統合 名前空間の移動 and/or 型の統合。 メソッド名等に変更の場合あり。
🚫廃止 型の廃止。 フレームワークの相当機能を使用してください。
✂分離 他アセンブリへの型の移動。
🈚変更なし 変更なし。
👋対象外 Smdn.dllへの統合の対象外。 旧アセンブリに維持されます。

新旧対応表 (Smdn.dll)

旧アセンブリ(Smdn.dll) 変更内容 新アセンブリ(Smdn.dll)
名前空間 型名 名前空間 型名
Mono.Simd SimdRuntime 🚫廃止 - -
Smdn ArrayExtensions 🈚変更なし - -
Smdn BinaryConvert ♻️型を統合 Smdn.IO.Binary BinaryConversion
Smdn ByteString ➡️移動 Smdn.Text -
Smdn ByteStringBuilder ➡️移動 Smdn.Text -
Smdn ConvertUtils ♻️型を統合 Smdn.Text StringConversion
Smdn EmptyArray 🚫廃止 - -
Smdn Endianness 🈚変更なし - -
Smdn EnumUtils ♻️型を統合 Smdn.Text StringConversion
Smdn ExceptionUtils 🈚変更なし - -
Smdn Fraction 🚫廃止 - -
Smdn MathUtils 🈚変更なし - -
Smdn MimeType 🈚変更なし - -
Smdn Platform 🈚変更なし - -
Smdn Runtime 🈚変更なし - -
Smdn RuntimeEnvironment 🈚変更なし - -
Smdn Shell ➡️移動 Smdn.OperatingSystem -
Smdn StringExtensions 🈚変更なし - -
Smdn UnixTimeStamp 🚫廃止 - -
Smdn UriUtils ↪️リネーム Smdn.Formats UriQuery
Smdn Urn ✂分離 (Smdn.Formats.Urn.dllへ)
Smdn Uuid 🈚変更なし - -
Smdn UuidVersion 🈚変更なし - -
Smdn.Collections IDictionaryExtensions 🚫廃止 - -
Smdn.Collections IEnumerableExtensions 🚫廃止 - -
Smdn.Collections KeyValuePair 🈚変更なし - -
Smdn.Collections ReadOnlyDictionary 🈚変更なし - -
Smdn.Formats Base64 🈚変更なし - -
Smdn.Formats Chars ↪️リネーム Smdn.Text Ascii+Chars
Smdn.Formats Csv ↪️リネーム Smdn.Formats CsvRecord
Smdn.Formats Hexadecimals ↪️リネーム Smdn.Text Ascii+Hexadecimals
Smdn.Formats Octets ↪️リネーム Smdn.Text Ascii+Octets
Smdn.IO CachedStreamBase ➡️移動 Smdn.IO.Streams.Caching -
Smdn.IO ChunkedMemoryStream ➡️移動 Smdn.IO.Streams -
Smdn.IO DirectoryInfoExtensions 🈚変更なし - -
Smdn.IO DirectoryUtils 🈚変更なし - -
Smdn.IO NonClosingStream ➡️移動 Smdn.IO.Streams -
Smdn.IO NonPersistentCachedStream ➡️移動 Smdn.IO.Streams.Caching -
Smdn.IO PartialStream ➡️移動 Smdn.IO.Streams -
Smdn.IO PathUtils 🈚変更なし - -
Smdn.IO PersistentCachedStream ➡️移動 Smdn.IO.Streams.Caching -
Smdn.IO StreamExtensions 🈚変更なし - -
Smdn.IO TextReaderExtensions 🈚変更なし - -
Smdn.Media WAVE_FORMAT ✂分離 (Smdn.Media.dllへ)
Smdn.Media WAVE_FORMAT_TAG ✂分離 (Smdn.Media.dllへ)
Smdn.Media WAVEFORMATEX ✂分離 (Smdn.Media.dllへ)
Smdn.Security.Cryptography IcryptoTransformExtensions 🈚変更なし - -

新旧対応表 (Smdn.Core.Standards.dll)

旧アセンブリ(Smdn.Core.Standards.dll) 変更内容 新アセンブリ(Smdn.dll)
名前空間 型名 名前空間 型名
Smdn.Formats CsvReader ➡️移動 Smdn.Formats.Csv -
Smdn.Formats CsvWriter ➡️移動 Smdn.Formats.Csv -
Smdn.Formats DateTimeConvert ↪️リネーム Smdn.Formats DateTimeFormat
Smdn.Formats EncodingNotSupportedException ➡️移動 Smdn.Text.Encodings -
Smdn.Formats EncodingSelectionCallback ➡️移動 Smdn.Text.Encodings -
Smdn.Formats EncodingUtils ➡️移動 Smdn.Text.Encodings -
Smdn.Formats FromPercentEncodedTransform ➡️移動 Smdn.Formats.PercentEncodings -
Smdn.Formats FromRFC2152ModifiedBase64Transform ➡️移動 Smdn.Formats.ModifiedBase64 -
Smdn.Formats FromRFC3501ModifiedBase64Transform ➡️移動 Smdn.Formats.ModifiedBase64 -
Smdn.Formats HtmlEscape ↪️リネーム Smdn.Formats Html
Smdn.Formats ModifiedUTF7 ➡️移動 Smdn.Formats.ModifiedBase64 -
Smdn.Formats PercentEncoding ➡️移動 Smdn.Formats.PercentEncodings -
Smdn.Formats ToPercentEncodedTransform ➡️移動 Smdn.Formats.PercentEncodings -
Smdn.Formats ToPercentEncodedTransformMode ➡️移動 Smdn.Formats.PercentEncodings -
Smdn.Formats ToRFC2152ModifiedBase64Transform ➡️移動 Smdn.Formats.ModifiedBase64 -
Smdn.Formats ToRFC3501ModifiedBase64Transform ➡️移動 Smdn.Formats.ModifiedBase64 -
Smdn.Formats.Mime ContentTransferEncoding 🈚変更なし - -
Smdn.Formats.Mime ContentTransferEncodingMethod 🈚変更なし - -
Smdn.Formats.Mime FromQuotedPrintableTransform ➡️移動 Smdn.Formats.QuotedPrintableEncodings -
Smdn.Formats.Mime FromQuotedPrintableTransformMode ➡️移動 Smdn.Formats.QuotedPrintableEncodings -
Smdn MimeEncodedWordConverter ➡️移動 Smdn.Formats.Mime -
Smdn.Formats.Mime MimeEncoding 🈚変更なし - -
Smdn.Formats.Mime MimeEncodingMethod 🈚変更なし - -
Smdn.Formats.Mime MimeUtils 🈚変更なし - -
Smdn.Formats.Mime QuotedPrintableEncoding ➡️移動 Smdn.Formats.QuotedPrintableEncodings -
Smdn.Formats.Mime ToQuotedPrintableTransform ➡️移動 Smdn.Formats.QuotedPrintableEncodings -
Smdn.Formats.Mime ToQuotedPrintableTransformMode ➡️移動 Smdn.Formats.QuotedPrintableEncodings -
Smdn.Formats.UUEncoding UUDecoder ➡️移動 Smdn.Formats.UUEncodings -
Smdn.Formats.UUEncoding UUDecodingStream ➡️移動 Smdn.Formats.UUEncodings -
Smdn.Formats.UUEncoding UUDecodingTransform ➡️移動 Smdn.Formats.UUEncodings -
Smdn.IO LineOrientedStream ➡️移動 Smdn.IO.Streams.LineOriented -
Smdn.IO LooseLineOrientedStream ➡️移動 Smdn.IO.Streams.LineOriented -
Smdn.IO StrictLineOrientedStream ➡️移動 Smdn.IO.Streams.LineOriented -

新旧対応表 (Smdn.Core.BinaryFormats.dll)

旧アセンブリ(Smdn.Core.BinaryFormats.dll) 変更内容 新アセンブリ(Smdn.dll)
名前空間 型名 名前空間 型名
Smdn BinaryConvertExtensions ♻️型を統合 Smdn.IO.Binary BinaryConversion
Smdn FourCC 🈚変更なし - -
Smdn UInt24 🈚変更なし - -
Smdn UInt48 🈚変更なし - -
Smdn.IO BigEndianBinaryReader ➡️移動 Smdn.IO.Binary -
Smdn.IO BigEndianBinaryWriter ➡️移動 Smdn.IO.Binary -
Smdn.IO BinaryReader ➡️移動 Smdn.IO.Binary -
Smdn.IO BinaryReaderBase ➡️移動 Smdn.IO.Binary -
Smdn.IO BinaryWriter ➡️移動 Smdn.IO.Binary -
Smdn.IO BinaryWriterBase ➡️移動 Smdn.IO.Binary -
Smdn.IO ExtendStream ➡️移動 Smdn.IO.Streams -
Smdn.IO ExtendStreamBase ➡️移動 Smdn.IO.Streams -
Smdn.IO LittleEndianBinaryReader ➡️移動 Smdn.IO.Binary -
Smdn.IO LittleEndianBinaryWriter ➡️移動 Smdn.IO.Binary -

新旧対応表 (Smdn.Core.Miscellaneous.dll)

旧アセンブリ(Smdn.Core.Miscellaneous.dll) 変更内容 新アセンブリ(Smdn.dll)
名前空間 型名 名前空間 型名
Smdn ConsoleUtils 👋対象外 - -
Smdn EnvironmentUtils ↪️リネーム Smdn.OperatingSystem EnvironmentVariable
Smdn.Formats SIPrefixFormat ↪️リネーム Smdn.Formats SIPrefixNumberFormatter
Smdn.IO CachedWebFile 👋対象外 - -
Smdn.IO FileDialogFilter 👋対象外 - -
Smdn.IO FileManager 👋対象外 - -
Smdn.IO PipeOutStream ➡️移動 Smdn.OperatingSystem -
Smdn.IO ShellString ➡️移動 Smdn.OperatingSystem -
Smdn.Net WsseClient 👋対象外 - -
Smdn.Threading ProcessLock 👋対象外 - -
Smdn.Threading QueueingBackgroundWorker 👋対象外 - -
Smdn.Xml XmlCachedUrlResolver 👋対象外 - -

新旧対応表 (その他のアセンブリ)

旧アセンブリ 変更内容 新アセンブリ(Smdn.dll)
名前空間 型名 名前空間 型名
Smdn.Net.Imap4.dll
Smdn.Net.Imap4 CollectionUtils ♻️型を統合 Smdn.Text StringConversion
Smdn.Net.MessageAccessProtocols.dll
Smdn.Net.MessageAccessProtocols NetworkTransferEncoding ↪️リネーム Smdn.Text.Encodings OctetEncoding

APIリスト

API差分 Smdn-2.02-netfx4.5 vs Smdn-3.0beta1-net471

Smdn-2.02-netfx4.5_vs_3.0beta1-net471.apilist.diff
--- Smdn-2.02-netfx4.5.apilist.cs	2018-12-04 18:09:55.866598306 +0900
+++ Smdn-3.0beta1-net471.apilist.cs	2018-12-04 18:09:58.034569849 +0900
@@ -1,951 +1,1781 @@
-// Smdn-2.02-netfx4.5
+// Smdn-3.0beta1 (net471)
 //   Name: Smdn
-//   TargetFramework: .NETFramework,Version=v4.5
-//   AssemblyVersion: 2.2.0.0
-//   InformationalVersion: 2.02-netfx4.5
+//   TargetFramework: .NETFramework,Version=v4.7.1
+//   AssemblyVersion: 3.0.0.0
+//   InformationalVersion: 3.0beta1 (net471)
 
 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 Smdn;
-using Smdn.IO;
-using Smdn.Media;
+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 abstract class BinaryConvert {
-    protected BinaryConvert() {}
-
-    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) {}
-    protected static void CheckDestArray(byte[] bytes, int startIndex, int count) {}
-    protected static void CheckSourceArray(byte[] @value, int startIndex, int count) {}
-    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(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(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(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(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(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) {}
-    protected static Exception GetUnsupportedEndianException(Endianness endian) {}
-    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 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 ulong ToUInt64(byte[] @value, int startIndex, Endianness endian) {}
-    public static ulong ToUInt64BE(byte[] @value, int startIndex) {}
-    public static ulong ToUInt64LE(byte[] @value, int startIndex) {}
-  }
-
-  [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) {}
-    [DebuggerHidden]
-    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 ConvertUtils {
-    public static bool? ToBooleanNullable(string val) {}
-    public static TEnum? ToEnumNullable<TEnum>(string val) where TEnum : struct {}
-    public static int? ToInt32Nullable(string val) {}
-    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) {}
-  }
-
-  public static class EmptyArray<T> {
-    public static readonly T[] Instance;
-  }
-
-  public static class EnumUtils {
-    public static TEnum Parse<TEnum>(string @value) where TEnum : struct {}
-    public static TEnum Parse<TEnum>(string @value, bool ignoreCase) where TEnum : struct {}
-    public static TEnum ParseIgnoreCase<TEnum>(string @value) where TEnum : struct {}
-    public static bool TryParseIgnoreCase<TEnum>(string @value, out TEnum result) where TEnum : struct {}
-  }
-
   public static class ExceptionUtils {
     public static ArgumentException CreateArgumentAttemptToAccessBeyondEndOfArray(string paramName, Array array, 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 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 : struct {}
     public static ArgumentException CreateArgumentMustBeValidEnumValue<TEnum>(string paramName, TEnum invalidValue, string additionalMessage) where TEnum : struct {}
     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 : struct {}
     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 MultipartAlternative; // = "multipart/alternative"
     public static readonly MimeType MultipartMixed; // = "multipart/mixed"
     public static readonly MimeType TextPlain; // = "text/plain"
 
     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 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 string[] FindExtensionsByMimeType(MimeType mimeType) {}
     public static string[] FindExtensionsByMimeType(MimeType mimeType, string mimeTypesFile) {}
     public static string[] FindExtensionsByMimeType(string mimeType) {}
     public static 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 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 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 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 bool IsSimdRuntimeAvailable { get; }
     public static string Name { get; }
     public static RuntimeEnvironment RuntimeEnvironment { get; }
-    public static int SimdRuntimeAccelMode { get; }
     public static Version Version { get; }
     public static string VersionString { get; }
   }
 
-  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 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 static class UnixTimeStamp {
-    public static readonly DateTime Epoch; // = "1970/01/01 0:00:00"
-
-    public static long Now { get; }
-    public static long UtcNow { get; }
+  public struct FourCC :
+    IEquatable<FourCC>,
+    IEquatable<byte[]>,
+    IEquatable<string>
+  {
+    public static readonly FourCC Empty; // = "\u0000\u0000\u0000\u0000"
 
-    public static int ToInt32(DateTime dateTime) {}
-    public static int ToInt32(DateTimeOffset dateTimeOffset) {}
-    public static long ToInt64(DateTime dateTime) {}
-    public static long ToInt64(DateTimeOffset dateTimeOffset) {}
-    public static DateTime ToLocalDateTime(int unixTime) {}
-    public static DateTime ToLocalDateTime(long unixTime) {}
-    public static DateTime ToUtcDateTime(int unixTime) {}
-    public static DateTime ToUtcDateTime(long unixTime) {}
+    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) {}
   }
 
-  public static class UriUtils {
-    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) {}
+  [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) {}
   }
 
-  public static class Urn {
-    public const string NamespaceIetf = "IETF";
-    public const string NamespaceIsbn = "ISBN";
-    public const string NamespaceIso = "iso";
-    public const string NamespaceUuid = "UUID";
-    public const string Scheme = "urn";
-
-    public static Uri Create(string nid, string nss) {}
-    public static string GetNamespaceIdentifier(Uri urn) {}
-    public static string GetNamespaceIdentifier(string urn) {}
-    public static string GetNamespaceSpecificString(Uri urn, string expectedNid) {}
-    public static string GetNamespaceSpecificString(string urn, string expectedNid) {}
-    public static void Split(Uri urn, out string nid, out string nns) {}
-    public static void Split(string urn, out string nid, out string nns) {}
-  }
-
-  public struct Fraction :
-    IEquatable<Fraction>,
-    IEquatable<double>
+  [StructLayout(LayoutKind.Explicit, Pack = 1)]
+  public struct UInt48 :
+    IComparable,
+    IComparable<UInt48>,
+    IComparable<long>,
+    IComparable<ulong>,
+    IConvertible,
+    IEquatable<UInt48>,
+    IEquatable<long>,
+    IEquatable<ulong>,
+    IFormattable
   {
-    public long Denominator;
-    public static readonly Fraction Empty; // = "0/0"
-    public long Numerator;
-    public static readonly Fraction One; // = "1/1"
-    public static readonly Fraction Zero; // = "0/1"
-
-    public Fraction(long numerator, long denominator) {}
-
-    public bool Equals(Fraction frac) {}
-    public bool Equals(double other) {}
-    public override bool Equals(object other) {}
+    [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() {}
-    public double ToDouble() {}
-    public int ToInt32() {}
+    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 static Fraction operator / (Fraction fraction, int number) {}
-    public static Fraction operator / (Fraction fraction, long number) {}
-    public static double operator / (double number, Fraction fraction) {}
-    public static int operator / (int number, Fraction fraction) {}
-    public static long operator / (long number, Fraction fraction) {}
-    public static explicit operator double(Fraction frac) {}
-    public static explicit operator int(Fraction frac) {}
-    public static explicit operator long(Fraction frac) {}
-    public static Fraction operator * (Fraction a, Fraction b) {}
-    public static double operator * (Fraction fraction, double number) {}
-    public static double operator * (double number, Fraction fraction) {}
-    public static int operator * (Fraction fraction, int number) {}
-    public static int operator * (int number, Fraction fraction) {}
-    public static long operator * (Fraction fraction, long number) {}
-    public static long operator * (long number, Fraction fraction) {}
+    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(Uri uuidUrn) {}
     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 Uri ToUrn() {}
     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 IDictionaryExtensions {
-    public static IDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) {}
-  }
-
-  public static class IEnumerableExtensions {
-    [DebuggerHidden]
-    public static IEnumerable<T> EnumerateDepthFirst<T>(this IEnumerable<T> nestedEnumerable) where T : IEnumerable<T> {}
-  }
-
   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;
   }
 }
 
 namespace Smdn.Formats {
   public static class Base64 {
-    public static Stream CreateDecodingStream(Stream stream) {}
-    public static Stream CreateEncodingStream(Stream stream) {}
+    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 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 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 static char[] GetLowerCaseHexChars() {}
-    public static char[] GetUpperCaseHexChars() {}
+    public string Format(string format, object arg, IFormatProvider formatProvider) {}
+    public object GetFormat(Type formatType) {}
   }
 
-  public static class Csv {
-    public static string ToJoined(params string[] csv) {}
-    public static string[] ToSplitted(string csv) {}
+  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 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 byte[] GetCRLF() {}
-    public static byte[] GetLowerCaseHexOctets() {}
-    public static byte[] GetToLowerCaseAsciiTable() {}
-    public static byte[] GetToUpperCaseAsciiTable() {}
-    public static byte[] GetUpperCaseHexOctets() {}
-    public static bool IsDecimalNumber(byte b) {}
+    public void WriteLine(params object[] columns) {}
+    public void WriteLine(params string[] columns) {}
   }
 }
 
-namespace Smdn.IO {
-  public abstract class CachedStreamBase : Stream {
-    protected CachedStreamBase(Stream innerStream, int blockSize, bool leaveInnerStreamOpen) {}
+namespace Smdn.Formats.Mime {
+  public delegate string MimeEncodedWordConverter(System.Text.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 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 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() {}
-    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 bool SeekToNextFile() {}
     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 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 Write(this Stream stream, ArraySegment<byte> segment) {}
+  }
+
+  public static class TextReaderExtensions {
+    public static string[] ReadAllLines(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 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 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) {}
 
-  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) {}
+    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 class NonClosingStream : Stream {
-    public NonClosingStream(Stream innerStream) {}
+  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 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 class NonClosingStream : Stream {
+    public NonClosingStream(Stream innerStream) {}
+
+    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() {}
-    protected override byte[] GetBlock(long blockIndex) {}
+    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) {}
   }
+}
 
-  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) {}
+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) {}
   }
+}
 
-  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 Write(this Stream stream, ArraySegment<byte> segment) {}
+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 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[] dest, 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 static class TextReaderExtensions {
-    public static string[] ReadAllLines(this TextReader reader) {}
-    [DebuggerHidden]
-    public static IEnumerable<string> ReadLines(this TextReader reader) {}
+  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.Media {
-  [Flags]
-  public enum WAVE_FORMAT : uint {
-    WAVE_FORMAT_1M08 = 0x00000001,
-    WAVE_FORMAT_1M16 = 0x00000004,
-    WAVE_FORMAT_1S08 = 0x00000002,
-    WAVE_FORMAT_1S16 = 0x00000008,
-    WAVE_FORMAT_2M08 = 0x00000010,
-    WAVE_FORMAT_2M16 = 0x00000040,
-    WAVE_FORMAT_2S08 = 0x00000020,
-    WAVE_FORMAT_2S16 = 0x00000080,
-    WAVE_FORMAT_48M08 = 0x00001000,
-    WAVE_FORMAT_48M16 = 0x00004000,
-    WAVE_FORMAT_48S08 = 0x00002000,
-    WAVE_FORMAT_48S16 = 0x00008000,
-    WAVE_FORMAT_4M08 = 0x00000100,
-    WAVE_FORMAT_4M16 = 0x00000400,
-    WAVE_FORMAT_4S08 = 0x00000200,
-    WAVE_FORMAT_4S16 = 0x00000800,
-    WAVE_FORMAT_96M08 = 0x00010000,
-    WAVE_FORMAT_96M16 = 0x00040000,
-    WAVE_FORMAT_96S08 = 0x00020000,
-    WAVE_FORMAT_96S16 = 0x00080000,
-    WAVE_INVALIDFORMAT = 0x00000000,
-  }
-
-  public enum WAVE_FORMAT_TAG : ushort {
-    WAVE_FORMAT_ADPCM = 2,
-    WAVE_FORMAT_EXTENSIBLE = 65534,
-    WAVE_FORMAT_IEEE_FLOAT = 3,
-    WAVE_FORMAT_MSAUDIO1 = 352,
-    WAVE_FORMAT_PCM = 1,
-    WAVE_FORMAT_UNKNOWN = 0,
-    WAVE_FORMAT_WMASPDIF = 356,
-    WAVE_FORMAT_WMAUDIO2 = 353,
-    WAVE_FORMAT_WMAUDIO3 = 354,
-    WAVE_FORMAT_WMAUDIO_LOSSLESS = 355,
-    WAVE_FORMAT_XMA2 = 358,
-  }
-
-  public struct WAVEFORMATEX {
-    public ushort cbSize;
-    public uint nAvgBytesPerSec;
-    public ushort nBlockAlign;
-    public ushort nChannels;
-    public uint nSamplesPerSec;
-    public ushort wBitsPerSample;
-    public WAVE_FORMAT_TAG wFormatTag;
-
-    public static WAVEFORMATEX CreateLinearPcmFormat(WAVE_FORMAT format) {}
-    public static WAVEFORMATEX CreateLinearPcmFormat(long samplesPerSec, int bitsPerSample, int channles) {}
-    public static bool Equals(WAVEFORMATEX x, WAVEFORMATEX y) {}
-    public static WAVEFORMATEX ReadFrom(Stream stream) {}
-    public void WriteTo(Stream stream) {}
+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 char[] GetLowerCaseHexChars() {}
+      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 byte[] GetCRLF() {}
+      public static byte[] GetLowerCaseHexOctets() {}
+      public static byte[] GetToLowerCaseAsciiTable() {}
+      public static byte[] GetToUpperCaseAsciiTable() {}
+      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 : struct {}
+    public static TEnum ToEnum<TEnum>(string @value, bool ignoreCase) where TEnum : struct {}
+    public static TEnum ToEnumIgnoreCase<TEnum>(string @value) where TEnum : struct {}
+    public static TEnum? ToEnumNullable<TEnum>(string val) where TEnum : struct {}
+    public static int? ToInt32Nullable(string val) {}
+    public static string ToJoinedString<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> pairs) {}
+    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) {}
+  }
+}
+

API差分 Smdn.Core.Standards-1.01-netfx4.5 vs Smdn-3.0beta1-net471

Smdn.Core.Standards-1.01-netfx4.5_vs_Smdn-3.0beta1-net471.apilist.diff
--- Smdn.Core.Standards-1.01-netfx4.5.apilist.cs	2018-12-04 18:10:13.098372116 +0900
+++ Smdn-3.0beta1-net471.apilist.cs	2018-12-04 18:10:15.778336937 +0900
@@ -1,444 +1,1781 @@
-// Smdn.Core.Standards-1.01-netfx4.5
-//   Name: Smdn.Core.Standards
-//   TargetFramework: 
-//   AssemblyVersion: 1.1.0.0
-//   InformationalVersion: 1.01-netfx4.5
+// Smdn-3.0beta1 (net471)
+//   Name: Smdn
+//   TargetFramework: .NETFramework,Version=v4.7.1
+//   AssemblyVersion: 3.0.0.0
+//   InformationalVersion: 3.0beta1 (net471)
 
 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 Smdn;
 using Smdn.Formats;
 using Smdn.Formats.Mime;
-using Smdn.Formats.UUEncoding;
-using Smdn.IO;
+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 delegate string MimeEncodedWordConverter(System.Text.Encoding charset, string encodingMethod, string encodedText);
-}
+  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 CreateArgumentAttemptToAccessBeyondEndOfArray(string paramName, Array array, 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 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 : struct {}
+    public static ArgumentException CreateArgumentMustBeValidEnumValue<TEnum>(string paramName, TEnum invalidValue, string additionalMessage) where TEnum : struct {}
+    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 : struct {}
+    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 MultipartAlternative; // = "multipart/alternative"
+    public static readonly MimeType MultipartMixed; // = "multipart/mixed"
+    public static readonly MimeType TextPlain; // = "text/plain"
+
+    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 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 string[] FindExtensionsByMimeType(MimeType mimeType) {}
+    public static string[] FindExtensionsByMimeType(MimeType mimeType, string mimeTypesFile) {}
+    public static string[] FindExtensionsByMimeType(string mimeType) {}
+    public static 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 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 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 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,
+    }
 
-namespace Smdn.Formats {
-  public delegate Encoding EncodingSelectionCallback(string name);
+    public enum Variant : byte {
+      MicrosoftReserved = 192,
+      NCSReserved = 0,
+      RFC4122 = 128,
+      Reserved = 224,
+    }
 
-  [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 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) {}
   }
+}
 
-  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() {}
+namespace Smdn.Collections {
+  public static class KeyValuePair {
+    public static KeyValuePair<TKey, TValue> Create<TKey, TValue>(TKey key, TValue @value) {}
   }
 
-  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 static class ReadOnlyDictionary<TKey, TValue> {
+    public static readonly IReadOnlyDictionary<TKey, TValue> Empty;
+  }
+}
 
-    public char Delimiter { get; set; }
-    public bool EscapeAlways { get; set; }
-    public char Quotator { get; set; }
+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 void WriteLine(params object[] columns) {}
-    public void WriteLine(params string[] columns) {}
+  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 DateTimeConvert {
+  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) {}
   }
 
-  [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 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 class FromRFC2152ModifiedBase64Transform : FromBase64Transform {
-    public FromRFC2152ModifiedBase64Transform() {}
-    public FromRFC2152ModifiedBase64Transform(FromBase64TransformMode whitespaces) {}
-
-    public int InputBlockSize { get; }
-
-    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 whitespaces) {}
-
-    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 HtmlEscape {
+  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 static class ModifiedUTF7 {
-    public static string Decode(string str) {}
-    public static string Encode(string str) {}
-  }
-
-  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 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) {}
   }
+}
 
-  public sealed class ToPercentEncodedTransform : ICryptoTransform {
-    public ToPercentEncodedTransform(ToPercentEncodedTransformMode mode) {}
+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 bool CanReuseTransform { get; }
-    public bool CanTransformMultipleBlocks { get; }
-    public int InputBlockSize { get; }
-    public int OutputBlockSize { get; }
+    public char Delimiter { get; set; }
+    public bool EscapeAlways { get; set; }
+    public char Quotator { get; set; }
 
-    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 string[] ReadLine() {}
   }
 
-  public class ToRFC2152ModifiedBase64Transform : ToBase64Transform {
-    public ToRFC2152ModifiedBase64Transform() {}
-
-    public virtual byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
-  }
+  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 sealed class ToRFC3501ModifiedBase64Transform : ToRFC2152ModifiedBase64Transform {
-    public ToRFC3501ModifiedBase64Transform() {}
+    public char Delimiter { get; set; }
+    public bool EscapeAlways { get; set; }
+    public char Quotator { get; set; }
 
-    public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {}
-    public override byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
+    public void WriteLine(params object[] columns) {}
+    public void WriteLine(params string[] columns) {}
   }
 }
 
 namespace Smdn.Formats.Mime {
+  public delegate string MimeEncodedWordConverter(System.Text.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 FromQuotedPrintableTransformMode : int {
-    ContentTransferEncoding = 0,
-    MimeEncoding = 1,
-  }
-
   public enum MimeEncodingMethod : int {
     BEncoding = 1,
     Base64 = 1,
     None = 0,
     QEncoding = 2,
     QuotedPrintable = 2,
   }
 
-  public enum ToQuotedPrintableTransformMode : int {
-    ContentTransferEncoding = 0,
-    MimeEncoding = 1,
-  }
-
   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 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 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) {}
-    [DebuggerHidden]
     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) {}
-    [DebuggerHidden]
     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) {}
-    public static Stream CreateEncodingStream(Stream stream) {}
+    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.UUEncoding {
+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) {}
     }
 
-    [DebuggerHidden]
     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 Write(this Stream stream, ArraySegment<byte> segment) {}
+  }
+
+  public static class TextReaderExtensions {
+    public static string[] ReadAllLines(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 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 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[] dest, 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 char[] GetLowerCaseHexChars() {}
+      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 byte[] GetCRLF() {}
+      public static byte[] GetLowerCaseHexOctets() {}
+      public static byte[] GetToLowerCaseAsciiTable() {}
+      public static byte[] GetToUpperCaseAsciiTable() {}
+      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 : struct {}
+    public static TEnum ToEnum<TEnum>(string @value, bool ignoreCase) where TEnum : struct {}
+    public static TEnum ToEnumIgnoreCase<TEnum>(string @value) where TEnum : struct {}
+    public static TEnum? ToEnumNullable<TEnum>(string val) where TEnum : struct {}
+    public static int? ToInt32Nullable(string val) {}
+    public static string ToJoinedString<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> pairs) {}
+    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) {}
+  }
+}
+

APIリスト Smdn-2.02-netfx4.5

Smdn-2.02-netfx4.5.apilist.cs
// Smdn-2.02-netfx4.5
//   Name: Smdn
//   TargetFramework: .NETFramework,Version=v4.5
//   AssemblyVersion: 2.2.0.0
//   InformationalVersion: 2.02-netfx4.5

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.NetworkInformation;
using System.Runtime.Serialization;
using System.Security.Cryptography;
using System.Text;
using Smdn;
using Smdn.IO;
using Smdn.Media;

namespace Smdn {
  public enum Endianness : int {
    BigEndian = 0,
    LittleEndian = 1,
    Unknown = 2,
  }

  public enum RuntimeEnvironment : int {
    Mono = 2,
    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 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 abstract class BinaryConvert {
    protected BinaryConvert() {}

    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) {}
    protected static void CheckDestArray(byte[] bytes, int startIndex, int count) {}
    protected static void CheckSourceArray(byte[] @value, int startIndex, int count) {}
    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(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(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(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(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(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) {}
    protected static Exception GetUnsupportedEndianException(Endianness endian) {}
    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 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 ulong ToUInt64(byte[] @value, int startIndex, Endianness endian) {}
    public static ulong ToUInt64BE(byte[] @value, int startIndex) {}
    public static ulong ToUInt64LE(byte[] @value, int startIndex) {}
  }

  [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) {}
    [DebuggerHidden]
    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 ConvertUtils {
    public static bool? ToBooleanNullable(string val) {}
    public static TEnum? ToEnumNullable<TEnum>(string val) where TEnum : struct {}
    public static int? ToInt32Nullable(string val) {}
    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) {}
  }

  public static class EmptyArray<T> {
    public static readonly T[] Instance;
  }

  public static class EnumUtils {
    public static TEnum Parse<TEnum>(string @value) where TEnum : struct {}
    public static TEnum Parse<TEnum>(string @value, bool ignoreCase) where TEnum : struct {}
    public static TEnum ParseIgnoreCase<TEnum>(string @value) where TEnum : struct {}
    public static bool TryParseIgnoreCase<TEnum>(string @value, out TEnum result) where TEnum : struct {}
  }

  public static class ExceptionUtils {
    public static ArgumentException CreateArgumentAttemptToAccessBeyondEndOfArray(string paramName, Array array, 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 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 : struct {}
    public static ArgumentException CreateArgumentMustBeValidEnumValue<TEnum>(string paramName, TEnum invalidValue, string additionalMessage) where TEnum : struct {}
    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 : struct {}
    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 MultipartAlternative; // = "multipart/alternative"
    public static readonly MimeType MultipartMixed; // = "multipart/mixed"
    public static readonly MimeType TextPlain; // = "text/plain"

    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 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 string[] FindExtensionsByMimeType(MimeType mimeType) {}
    public static string[] FindExtensionsByMimeType(MimeType mimeType, string mimeTypesFile) {}
    public static string[] FindExtensionsByMimeType(string mimeType) {}
    public static 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 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 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 Platform {
    public static readonly Endianness Endianness = Endianness.LittleEndian;

    public static string DistributionName { get; }
    public static string KernelName { get; }
    public static string ProcessorName { get; }
  }

  public static class Runtime {
    public static bool IsRunningOnMono { get; }
    public static bool IsRunningOnNetFx { get; }
    public static bool IsRunningOnUnix { get; }
    public static bool IsRunningOnWindows { get; }
    public static bool IsSimdRuntimeAvailable { get; }
    public static string Name { get; }
    public static RuntimeEnvironment RuntimeEnvironment { get; }
    public static int SimdRuntimeAccelMode { get; }
    public static Version Version { get; }
    public static string VersionString { get; }
  }

  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 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 static class UnixTimeStamp {
    public static readonly DateTime Epoch; // = "1970/01/01 0:00:00"

    public static long Now { get; }
    public static long UtcNow { get; }

    public static int ToInt32(DateTime dateTime) {}
    public static int ToInt32(DateTimeOffset dateTimeOffset) {}
    public static long ToInt64(DateTime dateTime) {}
    public static long ToInt64(DateTimeOffset dateTimeOffset) {}
    public static DateTime ToLocalDateTime(int unixTime) {}
    public static DateTime ToLocalDateTime(long unixTime) {}
    public static DateTime ToUtcDateTime(int unixTime) {}
    public static DateTime ToUtcDateTime(long unixTime) {}
  }

  public static class UriUtils {
    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) {}
  }

  public static class Urn {
    public const string NamespaceIetf = "IETF";
    public const string NamespaceIsbn = "ISBN";
    public const string NamespaceIso = "iso";
    public const string NamespaceUuid = "UUID";
    public const string Scheme = "urn";

    public static Uri Create(string nid, string nss) {}
    public static string GetNamespaceIdentifier(Uri urn) {}
    public static string GetNamespaceIdentifier(string urn) {}
    public static string GetNamespaceSpecificString(Uri urn, string expectedNid) {}
    public static string GetNamespaceSpecificString(string urn, string expectedNid) {}
    public static void Split(Uri urn, out string nid, out string nns) {}
    public static void Split(string urn, out string nid, out string nns) {}
  }

  public struct Fraction :
    IEquatable<Fraction>,
    IEquatable<double>
  {
    public long Denominator;
    public static readonly Fraction Empty; // = "0/0"
    public long Numerator;
    public static readonly Fraction One; // = "1/1"
    public static readonly Fraction Zero; // = "0/1"

    public Fraction(long numerator, long denominator) {}

    public bool Equals(Fraction frac) {}
    public bool Equals(double other) {}
    public override bool Equals(object other) {}
    public override int GetHashCode() {}
    public double ToDouble() {}
    public int ToInt32() {}
    public long ToInt64() {}
    public override string ToString() {}
    public static Fraction operator / (Fraction fraction, int number) {}
    public static Fraction operator / (Fraction fraction, long number) {}
    public static double operator / (double number, Fraction fraction) {}
    public static int operator / (int number, Fraction fraction) {}
    public static long operator / (long number, Fraction fraction) {}
    public static explicit operator double(Fraction frac) {}
    public static explicit operator int(Fraction frac) {}
    public static explicit operator long(Fraction frac) {}
    public static Fraction operator * (Fraction a, Fraction b) {}
    public static double operator * (Fraction fraction, double number) {}
    public static double operator * (double number, Fraction fraction) {}
    public static int operator * (Fraction fraction, int number) {}
    public static int operator * (int number, Fraction fraction) {}
    public static long operator * (Fraction fraction, long number) {}
    public static long operator * (long number, Fraction fraction) {}
  }

  [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(Uri uuidUrn) {}
    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 Uri ToUrn() {}
    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 IDictionaryExtensions {
    public static IDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) {}
  }

  public static class IEnumerableExtensions {
    [DebuggerHidden]
    public static IEnumerable<T> EnumerateDepthFirst<T>(this IEnumerable<T> nestedEnumerable) where T : IEnumerable<T> {}
  }

  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;
  }
}

namespace Smdn.Formats {
  public static class Base64 {
    public static Stream CreateDecodingStream(Stream stream) {}
    public static Stream CreateEncodingStream(Stream stream) {}
    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 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 char[] GetLowerCaseHexChars() {}
    public static char[] GetUpperCaseHexChars() {}
  }

  public static class Csv {
    public static string ToJoined(params string[] csv) {}
    public static string[] ToSplitted(string csv) {}
  }

  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 byte[] GetCRLF() {}
    public static byte[] GetLowerCaseHexOctets() {}
    public static byte[] GetToLowerCaseAsciiTable() {}
    public static byte[] GetToUpperCaseAsciiTable() {}
    public static byte[] GetUpperCaseHexOctets() {}
    public static bool IsDecimalNumber(byte b) {}
  }
}

namespace Smdn.IO {
  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 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 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 class NonClosingStream : Stream {
    public NonClosingStream(Stream innerStream) {}

    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 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 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) {}
  }

  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 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) {}
  }

  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 Write(this Stream stream, ArraySegment<byte> segment) {}
  }

  public static class TextReaderExtensions {
    public static string[] ReadAllLines(this TextReader reader) {}
    [DebuggerHidden]
    public static IEnumerable<string> ReadLines(this TextReader reader) {}
  }
}

namespace Smdn.Media {
  [Flags]
  public enum WAVE_FORMAT : uint {
    WAVE_FORMAT_1M08 = 0x00000001,
    WAVE_FORMAT_1M16 = 0x00000004,
    WAVE_FORMAT_1S08 = 0x00000002,
    WAVE_FORMAT_1S16 = 0x00000008,
    WAVE_FORMAT_2M08 = 0x00000010,
    WAVE_FORMAT_2M16 = 0x00000040,
    WAVE_FORMAT_2S08 = 0x00000020,
    WAVE_FORMAT_2S16 = 0x00000080,
    WAVE_FORMAT_48M08 = 0x00001000,
    WAVE_FORMAT_48M16 = 0x00004000,
    WAVE_FORMAT_48S08 = 0x00002000,
    WAVE_FORMAT_48S16 = 0x00008000,
    WAVE_FORMAT_4M08 = 0x00000100,
    WAVE_FORMAT_4M16 = 0x00000400,
    WAVE_FORMAT_4S08 = 0x00000200,
    WAVE_FORMAT_4S16 = 0x00000800,
    WAVE_FORMAT_96M08 = 0x00010000,
    WAVE_FORMAT_96M16 = 0x00040000,
    WAVE_FORMAT_96S08 = 0x00020000,
    WAVE_FORMAT_96S16 = 0x00080000,
    WAVE_INVALIDFORMAT = 0x00000000,
  }

  public enum WAVE_FORMAT_TAG : ushort {
    WAVE_FORMAT_ADPCM = 2,
    WAVE_FORMAT_EXTENSIBLE = 65534,
    WAVE_FORMAT_IEEE_FLOAT = 3,
    WAVE_FORMAT_MSAUDIO1 = 352,
    WAVE_FORMAT_PCM = 1,
    WAVE_FORMAT_UNKNOWN = 0,
    WAVE_FORMAT_WMASPDIF = 356,
    WAVE_FORMAT_WMAUDIO2 = 353,
    WAVE_FORMAT_WMAUDIO3 = 354,
    WAVE_FORMAT_WMAUDIO_LOSSLESS = 355,
    WAVE_FORMAT_XMA2 = 358,
  }

  public struct WAVEFORMATEX {
    public ushort cbSize;
    public uint nAvgBytesPerSec;
    public ushort nBlockAlign;
    public ushort nChannels;
    public uint nSamplesPerSec;
    public ushort wBitsPerSample;
    public WAVE_FORMAT_TAG wFormatTag;

    public static WAVEFORMATEX CreateLinearPcmFormat(WAVE_FORMAT format) {}
    public static WAVEFORMATEX CreateLinearPcmFormat(long samplesPerSec, int bitsPerSample, int channles) {}
    public static bool Equals(WAVEFORMATEX x, WAVEFORMATEX y) {}
    public static WAVEFORMATEX ReadFrom(Stream stream) {}
    public void WriteTo(Stream stream) {}
  }
}

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) {}
  }
}

APIリスト Smdn.Core.Standards-1.01

Smdn.Core.Standards-1.01-netfx4.5.apilist.cs
// Smdn.Core.Standards-1.01-netfx4.5
//   Name: Smdn.Core.Standards
//   TargetFramework: 
//   AssemblyVersion: 1.1.0.0
//   InformationalVersion: 1.01-netfx4.5

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Security.Cryptography;
using System.Text;
using Smdn;
using Smdn.Formats;
using Smdn.Formats.Mime;
using Smdn.Formats.UUEncoding;
using Smdn.IO;

namespace Smdn {
  public delegate string MimeEncodedWordConverter(System.Text.Encoding charset, string encodingMethod, string encodedText);
}

namespace Smdn.Formats {
  public delegate Encoding EncodingSelectionCallback(string name);

  [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 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) {}
  }

  public static class DateTimeConvert {
    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) {}
  }

  [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 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 class FromRFC2152ModifiedBase64Transform : FromBase64Transform {
    public FromRFC2152ModifiedBase64Transform() {}
    public FromRFC2152ModifiedBase64Transform(FromBase64TransformMode whitespaces) {}

    public int InputBlockSize { get; }

    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 whitespaces) {}

    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 HtmlEscape {
    public static string FromHtmlEscapedString(string str) {}
    public static string FromNumericCharacterReference(string str) {}
    public static string FromXhtmlEscapedString(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 static class ModifiedUTF7 {
    public static string Decode(string str) {}
    public static string Encode(string str) {}
  }

  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) {}
  }

  public class ToRFC2152ModifiedBase64Transform : ToBase64Transform {
    public ToRFC2152ModifiedBase64Transform() {}

    public virtual byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {}
  }

  public sealed class ToRFC3501ModifiedBase64Transform : ToRFC2152ModifiedBase64Transform {
    public ToRFC3501ModifiedBase64Transform() {}

    public 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.Mime {
  public enum ContentTransferEncodingMethod : int {
    Base64 = 3,
    Binary = 2,
    EightBit = 1,
    GZip64 = 6,
    QuotedPrintable = 4,
    SevenBit = 0,
    UUEncode = 5,
    Unknown = 7,
  }

  public enum FromQuotedPrintableTransformMode : int {
    ContentTransferEncoding = 0,
    MimeEncoding = 1,
  }

  public enum MimeEncodingMethod : int {
    BEncoding = 1,
    Base64 = 1,
    None = 0,
    QEncoding = 2,
    QuotedPrintable = 2,
  }

  public enum ToQuotedPrintableTransformMode : int {
    ContentTransferEncoding = 0,
    MimeEncoding = 1,
  }

  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 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 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) {}
    [DebuggerHidden]
    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) {}
    [DebuggerHidden]
    public static IEnumerable<MimeUtils.HeaderField> ParseHeaderRaw(LineOrientedStream stream) {}
    public static string RemoveHeaderWhiteSpaceAndComment(string val) {}
  }

  public static class QuotedPrintableEncoding {
    public static Stream CreateDecodingStream(Stream stream) {}
    public static Stream CreateEncodingStream(Stream stream) {}
    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.UUEncoding {
  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) {}
    }

    [DebuggerHidden]
    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 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 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[] dest, 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) {}
  }
}

APIリスト Smdn-3.0beta1-net471

Smdn-3.0beta1-net471.apilist.cs
// Smdn-3.0beta1 (net471)
//   Name: Smdn
//   TargetFramework: .NETFramework,Version=v4.7.1
//   AssemblyVersion: 3.0.0.0
//   InformationalVersion: 3.0beta1 (net471)

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 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 CreateArgumentAttemptToAccessBeyondEndOfArray(string paramName, Array array, 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 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 : struct {}
    public static ArgumentException CreateArgumentMustBeValidEnumValue<TEnum>(string paramName, TEnum invalidValue, string additionalMessage) where TEnum : struct {}
    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 : struct {}
    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 MultipartAlternative; // = "multipart/alternative"
    public static readonly MimeType MultipartMixed; // = "multipart/mixed"
    public static readonly MimeType TextPlain; // = "text/plain"

    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 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 string[] FindExtensionsByMimeType(MimeType mimeType) {}
    public static string[] FindExtensionsByMimeType(MimeType mimeType, string mimeTypesFile) {}
    public static string[] FindExtensionsByMimeType(string mimeType) {}
    public static 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 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 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 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 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;
  }
}

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(System.Text.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 Write(this Stream stream, ArraySegment<byte> segment) {}
  }

  public static class TextReaderExtensions {
    public static string[] ReadAllLines(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 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 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[] dest, 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 char[] GetLowerCaseHexChars() {}
      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 byte[] GetCRLF() {}
      public static byte[] GetLowerCaseHexOctets() {}
      public static byte[] GetToLowerCaseAsciiTable() {}
      public static byte[] GetToUpperCaseAsciiTable() {}
      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 : struct {}
    public static TEnum ToEnum<TEnum>(string @value, bool ignoreCase) where TEnum : struct {}
    public static TEnum ToEnumIgnoreCase<TEnum>(string @value) where TEnum : struct {}
    public static TEnum? ToEnumNullable<TEnum>(string val) where TEnum : struct {}
    public static int? ToInt32Nullable(string val) {}
    public static string ToJoinedString<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> pairs) {}
    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) {}
  }
}