@tsonic/dotnet-pure/System.IO/internal/index.d.ts

TypeScript type definitions for .NET 10 BCL (Base Class Library) - CLR naming

// Generated by tsbindgen - Architecture
// Namespace: System.IO
// Assembly: System.IO.FileSystem.AccessControl, System.IO.FileSystem.DriveInfo, System.IO.FileSystem.Watcher, System.Private.CoreLib

// Branded primitive types are sourced from @tsonic/types
import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/types';

// Import support types from @tsonic/types
import type { ptr, ref } from "@tsonic/types";

// Import types from other namespaces
import type { SafeFileHandle } from "../../Microsoft.Win32.SafeHandles/internal/index.js";
import type { IAsyncEnumerable_1, IEnumerable_1, IReadOnlyList_1 } from "../../System.Collections.Generic/internal/index.js";
import type { Collection_1 } from "../../System.Collections.ObjectModel/internal/index.js";
import type { IDictionary } from "../../System.Collections/internal/index.js";
import * as System_ComponentModel_Internal from "../../System.ComponentModel/internal/index.js";
import type { Component, IComponent, IContainer, ISite, ISupportInitialize, ISynchronizeInvoke } from "../../System.ComponentModel/internal/index.js";
import type { MethodBase, MethodInfo } from "../../System.Reflection/internal/index.js";
import type { SafeBuffer } from "../../System.Runtime.InteropServices/internal/index.js";
import * as System_Runtime_Serialization_Internal from "../../System.Runtime.Serialization/internal/index.js";
import type { ISerializable, SerializationInfo, StreamingContext } from "../../System.Runtime.Serialization/internal/index.js";
import type { AccessControlSections, DirectorySecurity, FileSecurity, FileSystemRights } from "../../System.Security.AccessControl/internal/index.js";
import type { Encoding, StringBuilder } from "../../System.Text/internal/index.js";
import type { Task, Task_1, ValueTask, ValueTask_1 } from "../../System.Threading.Tasks/internal/index.js";
import type { CancellationToken } from "../../System.Threading/internal/index.js";
import * as System_Internal from "../../System/internal/index.js";
import type { ArraySegment_1, AsyncCallback, Boolean as ClrBoolean, Byte, Char, DateTime, Decimal, Delegate, Double, Enum, EventArgs, Exception, Half, IAsyncDisposable, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormatProvider, IFormattable, Int16, Int32, Int64, IntPtr, ISpanFormattable, MarshalByRefObject, Memory_1, MulticastDelegate, Nullable_1, Object as ClrObject, ReadOnlyMemory_1, ReadOnlySpan_1, SByte, Single, Span_1, String as ClrString, SystemException, TimeSpan, Type, TypeCode, UInt16, UInt32, UInt64, ValueType, Void } from "../../System/internal/index.js";

// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
// Value positions (parameters, return types) use lowercase primitives for ergonomics
export type CLROf<T> =
    T extends sbyte ? System_Internal.SByte :
    T extends short ? System_Internal.Int16 :
    T extends int ? System_Internal.Int32 :
    T extends long ? System_Internal.Int64 :
    T extends int128 ? System_Internal.Int128 :
    T extends nint ? System_Internal.IntPtr :
    T extends byte ? System_Internal.Byte :
    T extends ushort ? System_Internal.UInt16 :
    T extends uint ? System_Internal.UInt32 :
    T extends ulong ? System_Internal.UInt64 :
    T extends uint128 ? System_Internal.UInt128 :
    T extends nuint ? System_Internal.UIntPtr :
    T extends half ? System_Internal.Half :
    T extends float ? System_Internal.Single :
    T extends double ? System_Internal.Double :
    T extends decimal ? System_Internal.Decimal :
    T extends char ? System_Internal.Char :
    T extends boolean ? System_Internal.Boolean :
    T extends string ? System_Internal.String :
    T; // Identity fallback for non-primitive types

export enum DriveType {
    Unknown = 0,
    NoRootDirectory = 1,
    Removable = 2,
    Fixed = 3,
    Network = 4,
    CDRom = 5,
    Ram = 6
}


export enum FileAccess {
    Read = 1,
    Write = 2,
    ReadWrite = 3
}


export enum FileAttributes {
    None = 0,
    ReadOnly = 1,
    Hidden = 2,
    System = 4,
    Directory = 16,
    Archive = 32,
    Device = 64,
    Normal = 128,
    Temporary = 256,
    SparseFile = 512,
    ReparsePoint = 1024,
    Compressed = 2048,
    Offline = 4096,
    NotContentIndexed = 8192,
    Encrypted = 16384,
    IntegrityStream = 32768,
    NoScrubData = 131072
}


export enum FileMode {
    CreateNew = 1,
    Create = 2,
    Open = 3,
    OpenOrCreate = 4,
    Truncate = 5,
    Append = 6
}


export enum FileOptions {
    None = 0,
    WriteThrough = -2147483648,
    Asynchronous = 1073741824,
    RandomAccess = 268435456,
    DeleteOnClose = 67108864,
    SequentialScan = 134217728,
    Encrypted = 16384
}


export enum FileShare {
    None = 0,
    Read = 1,
    Write = 2,
    ReadWrite = 3,
    Delete = 4,
    Inheritable = 16
}


export enum HandleInheritability {
    None = 0,
    Inheritable = 1
}


export enum MatchCasing {
    PlatformDefault = 0,
    CaseSensitive = 1,
    CaseInsensitive = 2
}


export enum MatchType {
    Simple = 0,
    Win32 = 1
}


export enum NotifyFilters {
    FileName = 1,
    DirectoryName = 2,
    Attributes = 4,
    Size = 8,
    LastWrite = 16,
    LastAccess = 32,
    CreationTime = 64,
    Security = 256
}


export enum SearchOption {
    TopDirectoryOnly = 0,
    AllDirectories = 1
}


export enum SeekOrigin {
    Begin = 0,
    Current = 1,
    End = 2
}


export enum UnixFileMode {
    None = 0,
    OtherExecute = 1,
    OtherWrite = 2,
    OtherRead = 4,
    GroupExecute = 8,
    GroupWrite = 16,
    GroupRead = 32,
    UserExecute = 64,
    UserWrite = 128,
    UserRead = 256,
    StickyBit = 512,
    SetGroup = 1024,
    SetUser = 2048
}


export enum WatcherChangeTypes {
    Created = 1,
    Deleted = 2,
    Changed = 4,
    Renamed = 8,
    All = 15
}


export type ErrorEventHandler = (sender: unknown, e: ErrorEventArgs) => void;


export type FileSystemEventHandler = (sender: unknown, e: FileSystemEventArgs) => void;


export type RenamedEventHandler = (sender: unknown, e: RenamedEventArgs) => void;


export interface WaitForChangedResult$instance {
    ChangeType: WatcherChangeTypes;
    Name: string;
    OldName: string;
    TimedOut: boolean;
}


export const WaitForChangedResult: {
    new(): WaitForChangedResult$instance;
};


export type WaitForChangedResult = WaitForChangedResult$instance;

export interface BinaryReader$instance {
    readonly BaseStream: Stream;
    Close(): void;
    Dispose(): void;
    PeekChar(): int;
    Read(): int;
    Read(buffer: char[], index: int, count: int): int;
    Read(buffer: Span_1<CLROf<char>>): int;
    Read(buffer: byte[], index: int, count: int): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    Read7BitEncodedInt(): int;
    Read7BitEncodedInt64(): long;
    ReadBoolean(): boolean;
    ReadByte(): byte;
    ReadBytes(count: int): byte[];
    ReadChar(): char;
    ReadChars(count: int): char[];
    ReadDecimal(): decimal;
    ReadDouble(): double;
    ReadExactly(buffer: Span_1<CLROf<byte>>): void;
    ReadHalf(): half;
    ReadInt16(): short;
    ReadInt32(): int;
    ReadInt64(): long;
    ReadSByte(): sbyte;
    ReadSingle(): float;
    ReadString(): string;
    ReadUInt16(): ushort;
    ReadUInt32(): uint;
    ReadUInt64(): ulong;
}


export const BinaryReader: {
    new(input: Stream): BinaryReader$instance;
    new(input: Stream, encoding: Encoding): BinaryReader$instance;
    new(input: Stream, encoding: Encoding, leaveOpen: boolean): BinaryReader$instance;
};


export interface __BinaryReader$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface BinaryReader$instance extends System_Internal.IDisposable$instance {}

export type BinaryReader = BinaryReader$instance & __BinaryReader$views;


export interface BinaryWriter$instance {
    readonly BaseStream: Stream;
    Close(): void;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    Flush(): void;
    Seek(offset: int, origin: SeekOrigin): long;
    Write(value: boolean): void;
    Write(value: byte): void;
    Write(value: sbyte): void;
    Write(buffer: byte[]): void;
    Write(buffer: byte[], index: int, count: int): void;
    Write(ch: char): void;
    Write(chars: char[]): void;
    Write(chars: char[], index: int, count: int): void;
    Write(value: double): void;
    Write(value: decimal): void;
    Write(value: short): void;
    Write(value: ushort): void;
    Write(value: int): void;
    Write(value: uint): void;
    Write(value: long): void;
    Write(value: ulong): void;
    Write(value: float): void;
    Write(value: half): void;
    Write(value: string): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    Write(chars: ReadOnlySpan_1<CLROf<char>>): void;
    Write7BitEncodedInt(value: int): void;
    Write7BitEncodedInt64(value: long): void;
}


export const BinaryWriter: {
    new(output: Stream): BinaryWriter$instance;
    new(output: Stream, encoding: Encoding): BinaryWriter$instance;
    new(output: Stream, encoding: Encoding, leaveOpen: boolean): BinaryWriter$instance;
    readonly Null: BinaryWriter;
};


export interface __BinaryWriter$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface BinaryWriter$instance extends System_Internal.IAsyncDisposable$instance, System_Internal.IDisposable$instance {}

export type BinaryWriter = BinaryWriter$instance & __BinaryWriter$views;


export interface BufferedStream$instance extends Stream$instance {
    readonly BufferSize: int;
    readonly CanRead: boolean;
    readonly CanSeek: boolean;
    readonly CanWrite: boolean;
    readonly Length: long;
    Position: long;
    readonly UnderlyingStream: Stream;
    BeginRead(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    BeginWrite(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    CopyTo(destination: Stream, bufferSize: int): void;
    CopyTo(destination: Stream): void;
    CopyToAsync(destination: Stream, bufferSize: int, cancellationToken: CancellationToken): Task;
    CopyToAsync(destination: Stream): Task;
    CopyToAsync(destination: Stream, bufferSize: int): Task;
    CopyToAsync(destination: Stream, cancellationToken: CancellationToken): Task;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    EndRead(asyncResult: IAsyncResult): int;
    EndWrite(asyncResult: IAsyncResult): void;
    Flush(): void;
    FlushAsync(cancellationToken: CancellationToken): Task;
    FlushAsync(): Task;
    Read(buffer: byte[], offset: int, count: int): int;
    Read(destination: Span_1<CLROf<byte>>): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadByte(): int;
    Seek(offset: long, origin: SeekOrigin): long;
    SetLength(value: long): void;
    Write(buffer: byte[], offset: int, count: int): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    WriteAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteAsync(buffer: byte[], offset: int, count: int): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteByte(value: byte): void;
}


export const BufferedStream: {
    new(stream: Stream): BufferedStream$instance;
    new(stream: Stream, bufferSize: int): BufferedStream$instance;
};


export interface __BufferedStream$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type BufferedStream = BufferedStream$instance & __BufferedStream$views;


export interface DirectoryInfo$instance extends FileSystemInfo$instance {
    readonly Exists: boolean;
    readonly Name: string;
    readonly Parent: DirectoryInfo;
    readonly Root: DirectoryInfo;
    Create(): void;
    CreateSubdirectory(path: string): DirectoryInfo;
    Delete(): void;
    EnumerateDirectories(): IEnumerable_1<DirectoryInfo>;
    EnumerateDirectories(searchPattern: string): IEnumerable_1<DirectoryInfo>;
    EnumerateDirectories(searchPattern: string, searchOption: SearchOption): IEnumerable_1<DirectoryInfo>;
    EnumerateDirectories(searchPattern: string, enumerationOptions: EnumerationOptions): IEnumerable_1<DirectoryInfo>;
    EnumerateFiles(): IEnumerable_1<FileInfo>;
    EnumerateFiles(searchPattern: string): IEnumerable_1<FileInfo>;
    EnumerateFiles(searchPattern: string, searchOption: SearchOption): IEnumerable_1<FileInfo>;
    EnumerateFiles(searchPattern: string, enumerationOptions: EnumerationOptions): IEnumerable_1<FileInfo>;
    EnumerateFileSystemInfos(): IEnumerable_1<FileSystemInfo>;
    EnumerateFileSystemInfos(searchPattern: string): IEnumerable_1<FileSystemInfo>;
    EnumerateFileSystemInfos(searchPattern: string, searchOption: SearchOption): IEnumerable_1<FileSystemInfo>;
    EnumerateFileSystemInfos(searchPattern: string, enumerationOptions: EnumerationOptions): IEnumerable_1<FileSystemInfo>;
    GetDirectories(): DirectoryInfo[];
    GetDirectories(searchPattern: string): DirectoryInfo[];
    GetDirectories(searchPattern: string, searchOption: SearchOption): DirectoryInfo[];
    GetDirectories(searchPattern: string, enumerationOptions: EnumerationOptions): DirectoryInfo[];
    GetFiles(): FileInfo[];
    GetFiles(searchPattern: string): FileInfo[];
    GetFiles(searchPattern: string, searchOption: SearchOption): FileInfo[];
    GetFiles(searchPattern: string, enumerationOptions: EnumerationOptions): FileInfo[];
    GetFileSystemInfos(): FileSystemInfo[];
    GetFileSystemInfos(searchPattern: string): FileSystemInfo[];
    GetFileSystemInfos(searchPattern: string, searchOption: SearchOption): FileSystemInfo[];
    GetFileSystemInfos(searchPattern: string, enumerationOptions: EnumerationOptions): FileSystemInfo[];
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
    MoveTo(destDirName: string): void;
}


export const DirectoryInfo: {
    new(path: string): DirectoryInfo$instance;
};


export interface __DirectoryInfo$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type DirectoryInfo = DirectoryInfo$instance & __DirectoryInfo$views;


export interface DirectoryNotFoundException$instance extends IOException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const DirectoryNotFoundException: {
    new(): DirectoryNotFoundException$instance;
    new(message: string): DirectoryNotFoundException$instance;
    new(message: string, innerException: Exception): DirectoryNotFoundException$instance;
};


export interface __DirectoryNotFoundException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type DirectoryNotFoundException = DirectoryNotFoundException$instance & __DirectoryNotFoundException$views;


export interface DriveInfo$instance {
    readonly AvailableFreeSpace: long;
    readonly DriveFormat: string;
    readonly DriveType: DriveType;
    readonly IsReady: boolean;
    readonly Name: string;
    readonly RootDirectory: DirectoryInfo;
    readonly TotalFreeSpace: long;
    readonly TotalSize: long;
    VolumeLabel: string;
    ToString(): string;
}


export const DriveInfo: {
    new(driveName: string): DriveInfo$instance;
    GetDrives(): DriveInfo[];
};


export interface __DriveInfo$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export interface DriveInfo$instance extends System_Runtime_Serialization_Internal.ISerializable$instance {}

export type DriveInfo = DriveInfo$instance & __DriveInfo$views;


export interface DriveNotFoundException$instance extends IOException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const DriveNotFoundException: {
    new(): DriveNotFoundException$instance;
    new(message: string): DriveNotFoundException$instance;
    new(message: string, innerException: Exception): DriveNotFoundException$instance;
};


export interface __DriveNotFoundException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type DriveNotFoundException = DriveNotFoundException$instance & __DriveNotFoundException$views;


export interface EndOfStreamException$instance extends IOException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const EndOfStreamException: {
    new(): EndOfStreamException$instance;
    new(message: string): EndOfStreamException$instance;
    new(message: string, innerException: Exception): EndOfStreamException$instance;
};


export interface __EndOfStreamException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type EndOfStreamException = EndOfStreamException$instance & __EndOfStreamException$views;


export interface EnumerationOptions$instance {
    AttributesToSkip: FileAttributes;
    BufferSize: int;
    IgnoreInaccessible: boolean;
    MatchCasing: MatchCasing;
    MatchType: MatchType;
    MaxRecursionDepth: int;
    RecurseSubdirectories: boolean;
    ReturnSpecialDirectories: boolean;
}


export const EnumerationOptions: {
    new(): EnumerationOptions$instance;
};


export type EnumerationOptions = EnumerationOptions$instance;

export interface ErrorEventArgs$instance extends EventArgs {
    GetException(): Exception;
}


export const ErrorEventArgs: {
    new(exception: Exception): ErrorEventArgs$instance;
};


export type ErrorEventArgs = ErrorEventArgs$instance;

export interface FileInfo$instance extends FileSystemInfo$instance {
    readonly Directory: DirectoryInfo;
    readonly DirectoryName: string;
    readonly Exists: boolean;
    IsReadOnly: boolean;
    readonly Length: long;
    readonly Name: string;
    AppendText(): StreamWriter;
    CopyTo(destFileName: string): FileInfo;
    CopyTo(destFileName: string, overwrite: boolean): FileInfo;
    Create(): FileStream;
    CreateText(): StreamWriter;
    Decrypt(): void;
    Delete(): void;
    Encrypt(): void;
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
    MoveTo(destFileName: string): void;
    MoveTo(destFileName: string, overwrite: boolean): void;
    Open(options: FileStreamOptions): FileStream;
    Open(mode: FileMode): FileStream;
    Open(mode: FileMode, access: FileAccess): FileStream;
    Open(mode: FileMode, access: FileAccess, share: FileShare): FileStream;
    OpenRead(): FileStream;
    OpenText(): StreamReader;
    OpenWrite(): FileStream;
    Replace(destinationFileName: string, destinationBackupFileName: string): FileInfo;
    Replace(destinationFileName: string, destinationBackupFileName: string, ignoreMetadataErrors: boolean): FileInfo;
}


export const FileInfo: {
    new(fileName: string): FileInfo$instance;
};


export interface __FileInfo$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type FileInfo = FileInfo$instance & __FileInfo$views;


export interface FileLoadException$instance extends IOException$instance {
    readonly FileName: string;
    readonly FusionLog: string;
    readonly Message: string;
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
    ToString(): string;
}


export const FileLoadException: {
    new(): FileLoadException$instance;
    new(message: string): FileLoadException$instance;
    new(message: string, inner: Exception): FileLoadException$instance;
    new(message: string, fileName: string): FileLoadException$instance;
    new(message: string, fileName: string, inner: Exception): FileLoadException$instance;
};


export interface __FileLoadException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type FileLoadException = FileLoadException$instance & __FileLoadException$views;


export interface FileNotFoundException$instance extends IOException$instance {
    readonly FileName: string;
    readonly FusionLog: string;
    readonly Message: string;
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
    ToString(): string;
}


export const FileNotFoundException: {
    new(): FileNotFoundException$instance;
    new(message: string): FileNotFoundException$instance;
    new(message: string, innerException: Exception): FileNotFoundException$instance;
    new(message: string, fileName: string): FileNotFoundException$instance;
    new(message: string, fileName: string, innerException: Exception): FileNotFoundException$instance;
};


export interface __FileNotFoundException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type FileNotFoundException = FileNotFoundException$instance & __FileNotFoundException$views;


export interface FileStream$instance extends Stream$instance {
    readonly CanRead: boolean;
    readonly CanSeek: boolean;
    readonly CanWrite: boolean;
    readonly Handle: nint;
    readonly IsAsync: boolean;
    readonly Length: long;
    readonly Name: string;
    Position: long;
    readonly SafeFileHandle: SafeFileHandle;
    BeginRead(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    BeginWrite(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    CopyTo(destination: Stream, bufferSize: int): void;
    CopyTo(destination: Stream): void;
    CopyToAsync(destination: Stream, bufferSize: int, cancellationToken: CancellationToken): Task;
    CopyToAsync(destination: Stream): Task;
    CopyToAsync(destination: Stream, bufferSize: int): Task;
    CopyToAsync(destination: Stream, cancellationToken: CancellationToken): Task;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    EndRead(asyncResult: IAsyncResult): int;
    EndWrite(asyncResult: IAsyncResult): void;
    Flush(): void;
    FlushAsync(cancellationToken: CancellationToken): Task;
    FlushAsync(): Task;
    Lock(position: long, length: long): void;
    Read(buffer: byte[], offset: int, count: int): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadByte(): int;
    Seek(offset: long, origin: SeekOrigin): long;
    SetLength(value: long): void;
    Unlock(position: long, length: long): void;
    Write(buffer: byte[], offset: int, count: int): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    WriteAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteAsync(buffer: byte[], offset: int, count: int): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteByte(value: byte): void;
}


export const FileStream: {
    new(handle: nint, access: FileAccess): FileStream$instance;
    new(handle: nint, access: FileAccess, ownsHandle: boolean): FileStream$instance;
    new(handle: nint, access: FileAccess, ownsHandle: boolean, bufferSize: int): FileStream$instance;
    new(handle: nint, access: FileAccess, ownsHandle: boolean, bufferSize: int, isAsync: boolean): FileStream$instance;
    new(handle: SafeFileHandle, access: FileAccess): FileStream$instance;
    new(handle: SafeFileHandle, access: FileAccess, bufferSize: int): FileStream$instance;
    new(handle: SafeFileHandle, access: FileAccess, bufferSize: int, isAsync: boolean): FileStream$instance;
    new(path: string, mode: FileMode): FileStream$instance;
    new(path: string, mode: FileMode, access: FileAccess): FileStream$instance;
    new(path: string, mode: FileMode, access: FileAccess, share: FileShare): FileStream$instance;
    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int): FileStream$instance;
    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int, useAsync: boolean): FileStream$instance;
    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int, options: FileOptions): FileStream$instance;
    new(path: string, options: FileStreamOptions): FileStream$instance;
};


export interface __FileStream$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type FileStream = FileStream$instance & __FileStream$views;


export interface FileStreamOptions$instance {
    Access: FileAccess;
    BufferSize: int;
    Mode: FileMode;
    Options: FileOptions;
    PreallocationSize: long;
    Share: FileShare;
    UnixCreateMode: Nullable_1<UnixFileMode>;
}


export const FileStreamOptions: {
    new(): FileStreamOptions$instance;
};


export type FileStreamOptions = FileStreamOptions$instance;

export interface FileSystemEventArgs$instance extends EventArgs {
    readonly ChangeType: WatcherChangeTypes;
    readonly FullPath: string;
    readonly Name: string;
}


export const FileSystemEventArgs: {
    new(changeType: WatcherChangeTypes, directory: string, name: string): FileSystemEventArgs$instance;
};


export type FileSystemEventArgs = FileSystemEventArgs$instance;

export interface FileSystemInfo$instance extends MarshalByRefObject {
    Attributes: FileAttributes;
    CreationTime: DateTime;
    CreationTimeUtc: DateTime;
    readonly Exists: boolean;
    readonly Extension: string;
    readonly FullName: string;
    LastAccessTime: DateTime;
    LastAccessTimeUtc: DateTime;
    LastWriteTime: DateTime;
    LastWriteTimeUtc: DateTime;
    readonly LinkTarget: string;
    readonly Name: string;
    UnixFileMode: UnixFileMode;
    CreateAsSymbolicLink(pathToTarget: string): void;
    Delete(): void;
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
    Refresh(): void;
    ResolveLinkTarget(returnFinalTarget: boolean): FileSystemInfo;
    ToString(): string;
}


export const FileSystemInfo: {
};


export interface __FileSystemInfo$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export interface FileSystemInfo$instance extends System_Runtime_Serialization_Internal.ISerializable$instance {}

export type FileSystemInfo = FileSystemInfo$instance & __FileSystemInfo$views;


export interface FileSystemWatcher$instance extends Component {
    EnableRaisingEvents: boolean;
    Filter: string;
    readonly Filters: Collection_1<CLROf<string>>;
    IncludeSubdirectories: boolean;
    InternalBufferSize: int;
    NotifyFilter: NotifyFilters;
    Path: string;
    Site: ISite;
    SynchronizingObject: ISynchronizeInvoke;
    BeginInit(): void;
    Dispose(): void;
    EndInit(): void;
    WaitForChanged(changeType: WatcherChangeTypes): WaitForChangedResult;
    WaitForChanged(changeType: WatcherChangeTypes, timeout: int): WaitForChangedResult;
    WaitForChanged(changeType: WatcherChangeTypes, timeout: TimeSpan): WaitForChangedResult;
}


export const FileSystemWatcher: {
    new(): FileSystemWatcher$instance;
    new(path: string): FileSystemWatcher$instance;
    new(path: string, filter: string): FileSystemWatcher$instance;
};


export interface __FileSystemWatcher$views {
    As_IComponent(): System_ComponentModel_Internal.IComponent$instance;
    As_ISupportInitialize(): System_ComponentModel_Internal.ISupportInitialize$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface FileSystemWatcher$instance extends System_ComponentModel_Internal.IComponent$instance, System_ComponentModel_Internal.ISupportInitialize$instance {}

export type FileSystemWatcher = FileSystemWatcher$instance & __FileSystemWatcher$views;


export interface InternalBufferOverflowException$instance extends SystemException {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const InternalBufferOverflowException: {
    new(): InternalBufferOverflowException$instance;
    new(message: string): InternalBufferOverflowException$instance;
    new(message: string, inner: Exception): InternalBufferOverflowException$instance;
};


export interface __InternalBufferOverflowException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type InternalBufferOverflowException = InternalBufferOverflowException$instance & __InternalBufferOverflowException$views;


export interface InvalidDataException$instance extends SystemException {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const InvalidDataException: {
    new(): InvalidDataException$instance;
    new(message: string): InvalidDataException$instance;
    new(message: string, innerException: Exception): InvalidDataException$instance;
};


export interface __InvalidDataException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type InvalidDataException = InvalidDataException$instance & __InvalidDataException$views;


export interface IOException$instance extends SystemException {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const IOException: {
    new(): IOException$instance;
    new(message: string): IOException$instance;
    new(message: string, hresult: int): IOException$instance;
    new(message: string, innerException: Exception): IOException$instance;
};


export interface __IOException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type IOException = IOException$instance & __IOException$views;


export interface MemoryStream$instance extends Stream$instance {
    readonly CanRead: boolean;
    readonly CanSeek: boolean;
    readonly CanWrite: boolean;
    Capacity: int;
    readonly Length: long;
    Position: long;
    CopyTo(destination: Stream, bufferSize: int): void;
    CopyTo(destination: Stream): void;
    CopyToAsync(destination: Stream, bufferSize: int, cancellationToken: CancellationToken): Task;
    CopyToAsync(destination: Stream): Task;
    CopyToAsync(destination: Stream, bufferSize: int): Task;
    CopyToAsync(destination: Stream, cancellationToken: CancellationToken): Task;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    Flush(): void;
    FlushAsync(cancellationToken: CancellationToken): Task;
    FlushAsync(): Task;
    GetBuffer(): byte[];
    Read(buffer: byte[], offset: int, count: int): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadByte(): int;
    Seek(offset: long, loc: SeekOrigin): long;
    SetLength(value: long): void;
    ToArray(): byte[];
    TryGetBuffer(buffer: { value: ref<ArraySegment_1<CLROf<byte>>> }): boolean;
    Write(buffer: byte[], offset: int, count: int): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    WriteAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteAsync(buffer: byte[], offset: int, count: int): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteByte(value: byte): void;
    WriteTo(stream: Stream): void;
}


export const MemoryStream: {
    new(): MemoryStream$instance;
    new(capacity: int): MemoryStream$instance;
    new(buffer: byte[]): MemoryStream$instance;
    new(buffer: byte[], writable: boolean): MemoryStream$instance;
    new(buffer: byte[], index: int, count: int): MemoryStream$instance;
    new(buffer: byte[], index: int, count: int, writable: boolean): MemoryStream$instance;
    new(buffer: byte[], index: int, count: int, writable: boolean, publiclyVisible: boolean): MemoryStream$instance;
};


export interface __MemoryStream$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type MemoryStream = MemoryStream$instance & __MemoryStream$views;


export interface PathTooLongException$instance extends IOException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const PathTooLongException: {
    new(): PathTooLongException$instance;
    new(message: string): PathTooLongException$instance;
    new(message: string, innerException: Exception): PathTooLongException$instance;
};


export interface __PathTooLongException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type PathTooLongException = PathTooLongException$instance & __PathTooLongException$views;


export interface RenamedEventArgs$instance extends FileSystemEventArgs {
    readonly OldFullPath: string;
    readonly OldName: string;
}


export const RenamedEventArgs: {
    new(changeType: WatcherChangeTypes, directory: string, name: string, oldName: string): RenamedEventArgs$instance;
};


export type RenamedEventArgs = RenamedEventArgs$instance;

export interface Stream$instance extends MarshalByRefObject {
    readonly CanRead: boolean;
    readonly CanSeek: boolean;
    readonly CanTimeout: boolean;
    readonly CanWrite: boolean;
    readonly Length: long;
    Position: long;
    ReadTimeout: int;
    WriteTimeout: int;
    BeginRead(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    BeginWrite(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    Close(): void;
    CopyTo(destination: Stream): void;
    CopyTo(destination: Stream, bufferSize: int): void;
    CopyToAsync(destination: Stream): Task;
    CopyToAsync(destination: Stream, bufferSize: int): Task;
    CopyToAsync(destination: Stream, cancellationToken: CancellationToken): Task;
    CopyToAsync(destination: Stream, bufferSize: int, cancellationToken: CancellationToken): Task;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    EndRead(asyncResult: IAsyncResult): int;
    EndWrite(asyncResult: IAsyncResult): void;
    Flush(): void;
    FlushAsync(): Task;
    FlushAsync(cancellationToken: CancellationToken): Task;
    Read(buffer: byte[], offset: int, count: int): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    ReadAsync(buffer: byte[], offset: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadAtLeast(buffer: Span_1<CLROf<byte>>, minimumBytes: int, throwOnEndOfStream?: boolean): int;
    ReadAtLeastAsync(buffer: Memory_1<CLROf<byte>>, minimumBytes: int, throwOnEndOfStream?: boolean, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadByte(): int;
    ReadExactly(buffer: Span_1<CLROf<byte>>): void;
    ReadExactly(buffer: byte[], offset: int, count: int): void;
    ReadExactlyAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    ReadExactlyAsync(buffer: byte[], offset: int, count: int, cancellationToken?: CancellationToken): ValueTask;
    Seek(offset: long, origin: SeekOrigin): long;
    SetLength(value: long): void;
    Write(buffer: byte[], offset: int, count: int): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    WriteAsync(buffer: byte[], offset: int, count: int): Task;
    WriteAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteByte(value: byte): void;
}


export const Stream: {
    readonly Null: Stream;
    Synchronized(stream: Stream): Stream;
};


export interface __Stream$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface Stream$instance extends System_Internal.IAsyncDisposable$instance, System_Internal.IDisposable$instance {}

export type Stream = Stream$instance & __Stream$views;


export interface StreamReader$instance extends TextReader$instance {
    readonly BaseStream: Stream;
    readonly CurrentEncoding: Encoding;
    readonly EndOfStream: boolean;
    Close(): void;
    DiscardBufferedData(): void;
    Dispose(): void;
    Peek(): int;
    Read(): int;
    Read(buffer: char[], index: int, count: int): int;
    Read(buffer: Span_1<CLROf<char>>): int;
    Read(buffer: Span_1<CLROf<char>>): int;
    ReadAsync(buffer: char[], index: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<char>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadAsync(buffer: char[], index: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<char>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadBlock(buffer: char[], index: int, count: int): int;
    ReadBlock(buffer: Span_1<CLROf<char>>): int;
    ReadBlock(buffer: Span_1<CLROf<char>>): int;
    ReadBlockAsync(buffer: char[], index: int, count: int): Task_1<CLROf<int>>;
    ReadBlockAsync(buffer: Memory_1<CLROf<char>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadBlockAsync(buffer: char[], index: int, count: int): Task_1<CLROf<int>>;
    ReadBlockAsync(buffer: Memory_1<CLROf<char>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadLine(): string;
    ReadLineAsync(): Task_1<CLROf<string>>;
    ReadLineAsync(cancellationToken: CancellationToken): ValueTask_1<CLROf<string>>;
    ReadLineAsync(): Task_1<CLROf<string>>;
    ReadLineAsync(cancellationToken: CancellationToken): ValueTask_1<CLROf<string>>;
    ReadToEnd(): string;
    ReadToEndAsync(): Task_1<CLROf<string>>;
    ReadToEndAsync(cancellationToken: CancellationToken): Task_1<CLROf<string>>;
    ReadToEndAsync(): Task_1<CLROf<string>>;
    ReadToEndAsync(cancellationToken: CancellationToken): Task_1<CLROf<string>>;
}


export const StreamReader: {
    new(stream: Stream): StreamReader$instance;
    new(stream: Stream, detectEncodingFromByteOrderMarks: boolean): StreamReader$instance;
    new(stream: Stream, encoding: Encoding): StreamReader$instance;
    new(stream: Stream, encoding: Encoding, detectEncodingFromByteOrderMarks: boolean): StreamReader$instance;
    new(stream: Stream, encoding: Encoding, detectEncodingFromByteOrderMarks: boolean, bufferSize: int): StreamReader$instance;
    new(stream: Stream, encoding: Encoding, detectEncodingFromByteOrderMarks: boolean, bufferSize: int, leaveOpen: boolean): StreamReader$instance;
    new(path: string): StreamReader$instance;
    new(path: string, detectEncodingFromByteOrderMarks: boolean): StreamReader$instance;
    new(path: string, encoding: Encoding): StreamReader$instance;
    new(path: string, encoding: Encoding, detectEncodingFromByteOrderMarks: boolean): StreamReader$instance;
    new(path: string, encoding: Encoding, detectEncodingFromByteOrderMarks: boolean, bufferSize: int): StreamReader$instance;
    new(path: string, options: FileStreamOptions): StreamReader$instance;
    new(path: string, encoding: Encoding, detectEncodingFromByteOrderMarks: boolean, options: FileStreamOptions): StreamReader$instance;
};


export interface __StreamReader$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type StreamReader = StreamReader$instance & __StreamReader$views;


export interface StreamWriter$instance extends TextWriter$instance {
    AutoFlush: boolean;
    readonly BaseStream: Stream;
    readonly Encoding: Encoding;
    Close(): void;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    Flush(): void;
    FlushAsync(): Task;
    FlushAsync(cancellationToken: CancellationToken): Task;
    Write(value: char): void;
    Write(buffer: char[]): void;
    Write(buffer: char[], index: int, count: int): void;
    Write(buffer: ReadOnlySpan_1<CLROf<char>>): void;
    Write(value: string): void;
    Write(format: string, arg0: unknown): void;
    Write(format: string, arg0: unknown, arg1: unknown): void;
    Write(format: string, arg0: unknown, arg1: unknown, arg2: unknown): void;
    Write(format: string, arg: unknown[]): void;
    Write(format: string, arg: ReadOnlySpan_1<unknown>): void;
    Write(buffer: ReadOnlySpan_1<CLROf<char>>): void;
    Write(value: boolean): void;
    Write(value: int): void;
    Write(value: uint): void;
    Write(value: long): void;
    Write(value: ulong): void;
    Write(value: float): void;
    Write(value: double): void;
    Write(value: decimal): void;
    Write(value: unknown): void;
    Write(value: StringBuilder): void;
    Write(format: string, arg: ReadOnlySpan_1<unknown>): void;
    WriteAsync(value: char): Task;
    WriteAsync(value: string): Task;
    WriteAsync(buffer: char[], index: int, count: int): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<char>>, cancellationToken?: CancellationToken): Task;
    WriteAsync(value: StringBuilder, cancellationToken?: CancellationToken): Task;
    WriteAsync(buffer: char[]): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<char>>, cancellationToken?: CancellationToken): Task;
    WriteLine(value: string): void;
    WriteLine(buffer: ReadOnlySpan_1<CLROf<char>>): void;
    WriteLine(format: string, arg0: unknown): void;
    WriteLine(format: string, arg0: unknown, arg1: unknown): void;
    WriteLine(format: string, arg0: unknown, arg1: unknown, arg2: unknown): void;
    WriteLine(format: string, arg: unknown[]): void;
    WriteLine(format: string, arg: ReadOnlySpan_1<unknown>): void;
    WriteLine(): void;
    WriteLine(value: char): void;
    WriteLine(buffer: char[]): void;
    WriteLine(buffer: char[], index: int, count: int): void;
    WriteLine(buffer: ReadOnlySpan_1<CLROf<char>>): void;
    WriteLine(value: boolean): void;
    WriteLine(value: int): void;
    WriteLine(value: uint): void;
    WriteLine(value: long): void;
    WriteLine(value: ulong): void;
    WriteLine(value: float): void;
    WriteLine(value: double): void;
    WriteLine(value: decimal): void;
    WriteLine(value: StringBuilder): void;
    WriteLine(value: unknown): void;
    WriteLine(format: string, arg: ReadOnlySpan_1<unknown>): void;
    WriteLineAsync(): Task;
    WriteLineAsync(value: char): Task;
    WriteLineAsync(value: string): Task;
    WriteLineAsync(buffer: char[], index: int, count: int): Task;
    WriteLineAsync(buffer: ReadOnlyMemory_1<CLROf<char>>, cancellationToken?: CancellationToken): Task;
    WriteLineAsync(value: StringBuilder, cancellationToken?: CancellationToken): Task;
    WriteLineAsync(buffer: char[]): Task;
    WriteLineAsync(buffer: ReadOnlyMemory_1<CLROf<char>>, cancellationToken?: CancellationToken): Task;
}


export const StreamWriter: {
    new(stream: Stream): StreamWriter$instance;
    new(stream: Stream, encoding: Encoding): StreamWriter$instance;
    new(stream: Stream, encoding: Encoding, bufferSize: int): StreamWriter$instance;
    new(stream: Stream, encoding: Encoding, bufferSize: int, leaveOpen: boolean): StreamWriter$instance;
    new(path: string): StreamWriter$instance;
    new(path: string, append: boolean): StreamWriter$instance;
    new(path: string, append: boolean, encoding: Encoding): StreamWriter$instance;
    new(path: string, append: boolean, encoding: Encoding, bufferSize: int): StreamWriter$instance;
    new(path: string, options: FileStreamOptions): StreamWriter$instance;
    new(path: string, encoding: Encoding, options: FileStreamOptions): StreamWriter$instance;
};


export interface __StreamWriter$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type StreamWriter = StreamWriter$instance & __StreamWriter$views;


export interface StringReader$instance extends TextReader$instance {
    Close(): void;
    Dispose(): void;
    Peek(): int;
    Read(): int;
    Read(buffer: char[], index: int, count: int): int;
    Read(buffer: Span_1<CLROf<char>>): int;
    Read(buffer: Span_1<CLROf<char>>): int;
    ReadAsync(buffer: char[], index: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<char>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadAsync(buffer: char[], index: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<char>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadBlock(buffer: Span_1<CLROf<char>>): int;
    ReadBlock(buffer: char[], index: int, count: int): int;
    ReadBlock(buffer: Span_1<CLROf<char>>): int;
    ReadBlockAsync(buffer: char[], index: int, count: int): Task_1<CLROf<int>>;
    ReadBlockAsync(buffer: Memory_1<CLROf<char>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadBlockAsync(buffer: char[], index: int, count: int): Task_1<CLROf<int>>;
    ReadBlockAsync(buffer: Memory_1<CLROf<char>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadLine(): string;
    ReadLineAsync(): Task_1<CLROf<string>>;
    ReadLineAsync(cancellationToken: CancellationToken): ValueTask_1<CLROf<string>>;
    ReadLineAsync(): Task_1<CLROf<string>>;
    ReadLineAsync(cancellationToken: CancellationToken): ValueTask_1<CLROf<string>>;
    ReadToEnd(): string;
    ReadToEndAsync(): Task_1<CLROf<string>>;
    ReadToEndAsync(cancellationToken: CancellationToken): Task_1<CLROf<string>>;
    ReadToEndAsync(): Task_1<CLROf<string>>;
    ReadToEndAsync(cancellationToken: CancellationToken): Task_1<CLROf<string>>;
}


export const StringReader: {
    new(s: string): StringReader$instance;
};


export interface __StringReader$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type StringReader = StringReader$instance & __StringReader$views;


export interface StringWriter$instance extends TextWriter$instance {
    readonly Encoding: Encoding;
    Close(): void;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    FlushAsync(): Task;
    FlushAsync(cancellationToken: CancellationToken): Task;
    GetStringBuilder(): StringBuilder;
    ToString(): string;
    Write(value: char): void;
    Write(buffer: char[], index: int, count: int): void;
    Write(buffer: ReadOnlySpan_1<CLROf<char>>): void;
    Write(value: string): void;
    Write(value: StringBuilder): void;
    Write(buffer: char[]): void;
    Write(buffer: ReadOnlySpan_1<CLROf<char>>): void;
    Write(value: boolean): void;
    Write(value: int): void;
    Write(value: uint): void;
    Write(value: long): void;
    Write(value: ulong): void;
    Write(value: float): void;
    Write(value: double): void;
    Write(value: decimal): void;
    Write(value: unknown): void;
    Write(format: string, arg0: unknown): void;
    Write(format: string, arg0: unknown, arg1: unknown): void;
    Write(format: string, arg0: unknown, arg1: unknown, arg2: unknown): void;
    Write(format: string, arg: unknown[]): void;
    Write(format: string, arg: ReadOnlySpan_1<unknown>): void;
    WriteAsync(value: char): Task;
    WriteAsync(value: string): Task;
    WriteAsync(buffer: char[], index: int, count: int): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<char>>, cancellationToken?: CancellationToken): Task;
    WriteAsync(value: StringBuilder, cancellationToken?: CancellationToken): Task;
    WriteAsync(buffer: char[]): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<char>>, cancellationToken?: CancellationToken): Task;
    WriteLine(buffer: ReadOnlySpan_1<CLROf<char>>): void;
    WriteLine(value: StringBuilder): void;
    WriteLine(): void;
    WriteLine(value: char): void;
    WriteLine(buffer: char[]): void;
    WriteLine(buffer: char[], index: int, count: int): void;