@tsonic/dotnet 0.8.0 → 0.8.2

package/System.IO.Compression/internal/index.d.ts

@@ -60,7 +60,7 @@ export interface BrotliDecoder$instance {
 
 
 export const BrotliDecoder: {
-    new(): BrotliDecoder$instance;
+    new(): BrotliDecoder;
     tryDecompress(source: ReadOnlySpan_1<System_Internal.Byte>, destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
 };
 
@@ -82,7 +82,7 @@ export interface BrotliEncoder$instance {
 
 
 export const BrotliEncoder: {
-    new(quality: int, window: int): BrotliEncoder$instance;
+    new(quality: int, window: int): BrotliEncoder;
     getMaxCompressedLength(inputSize: int): int;
     tryCompress(source: ReadOnlySpan_1<System_Internal.Byte>, destination: Span_1<System_Internal.Byte>, bytesWritten: int, quality: int, window: int): boolean;
     tryCompress(source: ReadOnlySpan_1<System_Internal.Byte>, destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
@@ -104,7 +104,7 @@ export interface BrotliCompressionOptions$instance {
 
 
 export const BrotliCompressionOptions: {
-    new(): BrotliCompressionOptions$instance;
+    new(): BrotliCompressionOptions;
 };
 
 
@@ -117,8 +117,8 @@ export interface BrotliStream$instance extends Stream {
     readonly canWrite: boolean;
     readonly length: long;
     position: long;
-    beginRead(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback, asyncState: unknown): IAsyncResult;
-    beginWrite(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback, asyncState: unknown): IAsyncResult;
+    beginRead(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback | undefined, asyncState: unknown | undefined): IAsyncResult;
+    beginWrite(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback | undefined, asyncState: unknown | undefined): IAsyncResult;
     dispose(): void;
     disposeAsync(): ValueTask;
     endRead(asyncResult: IAsyncResult): int;
@@ -149,11 +149,11 @@ export interface BrotliStream$instance extends Stream {
 
 
 export const BrotliStream: {
-    new(stream: Stream, compressionLevel: CompressionLevel): BrotliStream$instance;
-    new(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: boolean): BrotliStream$instance;
-    new(stream: Stream, compressionOptions: BrotliCompressionOptions, leaveOpen: boolean): BrotliStream$instance;
-    new(stream: Stream, mode: CompressionMode): BrotliStream$instance;
-    new(stream: Stream, mode: CompressionMode, leaveOpen: boolean): BrotliStream$instance;
+    new(stream: Stream, compressionLevel: CompressionLevel): BrotliStream;
+    new(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: boolean): BrotliStream;
+    new(stream: Stream, compressionOptions: BrotliCompressionOptions, leaveOpen: boolean): BrotliStream;
+    new(stream: Stream, mode: CompressionMode): BrotliStream;
+    new(stream: Stream, mode: CompressionMode, leaveOpen: boolean): BrotliStream;
 };
 
 
@@ -172,8 +172,8 @@ export interface DeflateStream$instance extends Stream {
     readonly canWrite: boolean;
     readonly length: long;
     position: long;
-    beginRead(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback, asyncState: unknown): IAsyncResult;
-    beginWrite(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback, asyncState: unknown): IAsyncResult;
+    beginRead(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback | undefined, asyncState: unknown | undefined): IAsyncResult;
+    beginWrite(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback | undefined, asyncState: unknown | undefined): IAsyncResult;
     copyTo(destination: Stream, bufferSize: int): void;
     copyTo(destination: Stream): void;
     copyToAsync(destination: Stream, bufferSize: int, cancellationToken: CancellationToken): Task;
@@ -210,11 +210,11 @@ export interface DeflateStream$instance extends Stream {
 
 
 export const DeflateStream: {
-    new(stream: Stream, mode: CompressionMode): DeflateStream$instance;
-    new(stream: Stream, mode: CompressionMode, leaveOpen: boolean): DeflateStream$instance;
-    new(stream: Stream, compressionLevel: CompressionLevel): DeflateStream$instance;
-    new(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: boolean): DeflateStream$instance;
-    new(stream: Stream, compressionOptions: ZLibCompressionOptions, leaveOpen: boolean): DeflateStream$instance;
+    new(stream: Stream, mode: CompressionMode): DeflateStream;
+    new(stream: Stream, mode: CompressionMode, leaveOpen: boolean): DeflateStream;
+    new(stream: Stream, compressionLevel: CompressionLevel): DeflateStream;
+    new(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: boolean): DeflateStream;
+    new(stream: Stream, compressionOptions: ZLibCompressionOptions, leaveOpen: boolean): DeflateStream;
 };
 
 
@@ -233,8 +233,8 @@ export interface GZipStream$instance extends Stream {
     readonly canWrite: boolean;
     readonly length: long;
     position: long;
-    beginRead(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback, asyncState: unknown): IAsyncResult;
-    beginWrite(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback, asyncState: unknown): IAsyncResult;
+    beginRead(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback | undefined, asyncState: unknown | undefined): IAsyncResult;
+    beginWrite(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback | undefined, asyncState: unknown | undefined): IAsyncResult;
     copyTo(destination: Stream, bufferSize: int): void;
     copyTo(destination: Stream): void;
     copyToAsync(destination: Stream, bufferSize: int, cancellationToken: CancellationToken): Task;
@@ -271,11 +271,11 @@ export interface GZipStream$instance extends Stream {
 
 
 export const GZipStream: {
-    new(stream: Stream, mode: CompressionMode): GZipStream$instance;
-    new(stream: Stream, mode: CompressionMode, leaveOpen: boolean): GZipStream$instance;
-    new(stream: Stream, compressionLevel: CompressionLevel): GZipStream$instance;
-    new(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: boolean): GZipStream$instance;
-    new(stream: Stream, compressionOptions: ZLibCompressionOptions, leaveOpen: boolean): GZipStream$instance;
+    new(stream: Stream, mode: CompressionMode): GZipStream;
+    new(stream: Stream, mode: CompressionMode, leaveOpen: boolean): GZipStream;
+    new(stream: Stream, compressionLevel: CompressionLevel): GZipStream;
+    new(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: boolean): GZipStream;
+    new(stream: Stream, compressionOptions: ZLibCompressionOptions, leaveOpen: boolean): GZipStream;
 };
 
 
@@ -295,16 +295,16 @@ export interface ZipArchive$instance {
     createEntry(entryName: string, compressionLevel: CompressionLevel): ZipArchiveEntry;
     dispose(): void;
     disposeAsync(): ValueTask;
-    getEntry(entryName: string): ZipArchiveEntry;
+    getEntry(entryName: string): ZipArchiveEntry | undefined;
 }
 
 
 export const ZipArchive: {
-    new(stream: Stream): ZipArchive$instance;
-    new(stream: Stream, mode: ZipArchiveMode): ZipArchive$instance;
-    new(stream: Stream, mode: ZipArchiveMode, leaveOpen: boolean): ZipArchive$instance;
-    new(stream: Stream, mode: ZipArchiveMode, leaveOpen: boolean, entryNameEncoding: Encoding): ZipArchive$instance;
-    createAsync(stream: Stream, mode: ZipArchiveMode, leaveOpen: boolean, entryNameEncoding: Encoding, cancellationToken?: CancellationToken): Task_1<ZipArchive>;
+    new(stream: Stream): ZipArchive;
+    new(stream: Stream, mode: ZipArchiveMode): ZipArchive;
+    new(stream: Stream, mode: ZipArchiveMode, leaveOpen: boolean): ZipArchive;
+    new(stream: Stream, mode: ZipArchiveMode, leaveOpen: boolean, entryNameEncoding: Encoding | undefined): ZipArchive;
+    createAsync(stream: Stream, mode: ZipArchiveMode, leaveOpen: boolean, entryNameEncoding: Encoding | undefined, cancellationToken?: CancellationToken): Task_1<ZipArchive>;
 };
 
 
@@ -337,7 +337,7 @@ export interface ZipArchiveEntry$instance {
 
 
 export const ZipArchiveEntry: {
-    new(): ZipArchiveEntry$instance;
+    new(): ZipArchiveEntry;
 };
 
 
@@ -350,7 +350,7 @@ export interface ZLibCompressionOptions$instance {
 
 
 export const ZLibCompressionOptions: {
-    new(): ZLibCompressionOptions$instance;
+    new(): ZLibCompressionOptions;
 };
 
 
@@ -362,9 +362,9 @@ export interface ZLibException$instance extends IOException {
 
 
 export const ZLibException: {
-    new(message: string, zlibErrorContext: string, zlibErrorCode: int, zlibErrorMessage: string): ZLibException$instance;
-    new(): ZLibException$instance;
-    new(message: string, innerException: Exception): ZLibException$instance;
+    new(message: string, zlibErrorContext: string, zlibErrorCode: int, zlibErrorMessage: string): ZLibException;
+    new(): ZLibException;
+    new(message: string, innerException: Exception): ZLibException;
 };
 
 
@@ -382,8 +382,8 @@ export interface ZLibStream$instance extends Stream {
     readonly canWrite: boolean;
     readonly length: long;
     position: long;
-    beginRead(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback, asyncState: unknown): IAsyncResult;
-    beginWrite(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback, asyncState: unknown): IAsyncResult;
+    beginRead(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback | undefined, asyncState: unknown | undefined): IAsyncResult;
+    beginWrite(buffer: byte[], offset: int, count: int, asyncCallback: AsyncCallback | undefined, asyncState: unknown | undefined): IAsyncResult;
     copyTo(destination: Stream, bufferSize: int): void;
     copyTo(destination: Stream): void;
     copyToAsync(destination: Stream, bufferSize: int, cancellationToken: CancellationToken): Task;
@@ -420,11 +420,11 @@ export interface ZLibStream$instance extends Stream {
 
 
 export const ZLibStream: {
-    new(stream: Stream, mode: CompressionMode): ZLibStream$instance;
-    new(stream: Stream, mode: CompressionMode, leaveOpen: boolean): ZLibStream$instance;
-    new(stream: Stream, compressionLevel: CompressionLevel): ZLibStream$instance;
-    new(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: boolean): ZLibStream$instance;
-    new(stream: Stream, compressionOptions: ZLibCompressionOptions, leaveOpen: boolean): ZLibStream$instance;
+    new(stream: Stream, mode: CompressionMode): ZLibStream;
+    new(stream: Stream, mode: CompressionMode, leaveOpen: boolean): ZLibStream;
+    new(stream: Stream, compressionLevel: CompressionLevel): ZLibStream;
+    new(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: boolean): ZLibStream;
+    new(stream: Stream, compressionOptions: ZLibCompressionOptions, leaveOpen: boolean): ZLibStream;
 };
 
 
@@ -437,37 +437,37 @@ export type ZLibStream = ZLibStream$instance & __ZLibStream$views;
 
 
 export abstract class ZipFile$instance {
-    static createFromDirectory(sourceDirectoryName: string, destination: Stream, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, entryNameEncoding: Encoding): void;
+    static createFromDirectory(sourceDirectoryName: string, destination: Stream, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, entryNameEncoding: Encoding | undefined): void;
     static createFromDirectory(sourceDirectoryName: string, destination: Stream, compressionLevel: CompressionLevel, includeBaseDirectory: boolean): void;
     static createFromDirectory(sourceDirectoryName: string, destination: Stream): void;
-    static createFromDirectory(sourceDirectoryName: string, destinationArchiveFileName: string, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, entryNameEncoding: Encoding): void;
+    static createFromDirectory(sourceDirectoryName: string, destinationArchiveFileName: string, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, entryNameEncoding: Encoding | undefined): void;
     static createFromDirectory(sourceDirectoryName: string, destinationArchiveFileName: string, compressionLevel: CompressionLevel, includeBaseDirectory: boolean): void;
     static createFromDirectory(sourceDirectoryName: string, destinationArchiveFileName: string): void;
-    static createFromDirectoryAsync(sourceDirectoryName: string, destination: Stream, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, entryNameEncoding: Encoding, cancellationToken?: CancellationToken): Task;
+    static createFromDirectoryAsync(sourceDirectoryName: string, destination: Stream, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, entryNameEncoding: Encoding | undefined, cancellationToken?: CancellationToken): Task;
     static createFromDirectoryAsync(sourceDirectoryName: string, destination: Stream, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, cancellationToken?: CancellationToken): Task;
     static createFromDirectoryAsync(sourceDirectoryName: string, destination: Stream, cancellationToken?: CancellationToken): Task;
-    static createFromDirectoryAsync(sourceDirectoryName: string, destinationArchiveFileName: string, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, entryNameEncoding: Encoding, cancellationToken?: CancellationToken): Task;
+    static createFromDirectoryAsync(sourceDirectoryName: string, destinationArchiveFileName: string, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, entryNameEncoding: Encoding | undefined, cancellationToken?: CancellationToken): Task;
     static createFromDirectoryAsync(sourceDirectoryName: string, destinationArchiveFileName: string, compressionLevel: CompressionLevel, includeBaseDirectory: boolean, cancellationToken?: CancellationToken): Task;
     static createFromDirectoryAsync(sourceDirectoryName: string, destinationArchiveFileName: string, cancellationToken?: CancellationToken): Task;
     static extractToDirectory(source: Stream, destinationDirectoryName: string, overwriteFiles: boolean): void;
-    static extractToDirectory(source: Stream, destinationDirectoryName: string, entryNameEncoding: Encoding, overwriteFiles: boolean): void;
-    static extractToDirectory(source: Stream, destinationDirectoryName: string, entryNameEncoding: Encoding): void;
+    static extractToDirectory(source: Stream, destinationDirectoryName: string, entryNameEncoding: Encoding | undefined, overwriteFiles: boolean): void;
+    static extractToDirectory(source: Stream, destinationDirectoryName: string, entryNameEncoding: Encoding | undefined): void;
     static extractToDirectory(source: Stream, destinationDirectoryName: string): void;
     static extractToDirectory(sourceArchiveFileName: string, destinationDirectoryName: string, overwriteFiles: boolean): void;
-    static extractToDirectory(sourceArchiveFileName: string, destinationDirectoryName: string, entryNameEncoding: Encoding, overwriteFiles: boolean): void;
-    static extractToDirectory(sourceArchiveFileName: string, destinationDirectoryName: string, entryNameEncoding: Encoding): void;
+    static extractToDirectory(sourceArchiveFileName: string, destinationDirectoryName: string, entryNameEncoding: Encoding | undefined, overwriteFiles: boolean): void;
+    static extractToDirectory(sourceArchiveFileName: string, destinationDirectoryName: string, entryNameEncoding: Encoding | undefined): void;
     static extractToDirectory(sourceArchiveFileName: string, destinationDirectoryName: string): void;
     static extractToDirectoryAsync(source: Stream, destinationDirectoryName: string, overwriteFiles: boolean, cancellationToken?: CancellationToken): Task;
-    static extractToDirectoryAsync(source: Stream, destinationDirectoryName: string, entryNameEncoding: Encoding, overwriteFiles: boolean, cancellationToken?: CancellationToken): Task;
-    static extractToDirectoryAsync(source: Stream, destinationDirectoryName: string, entryNameEncoding: Encoding, cancellationToken?: CancellationToken): Task;
+    static extractToDirectoryAsync(source: Stream, destinationDirectoryName: string, entryNameEncoding: Encoding | undefined, overwriteFiles: boolean, cancellationToken?: CancellationToken): Task;
+    static extractToDirectoryAsync(source: Stream, destinationDirectoryName: string, entryNameEncoding: Encoding | undefined, cancellationToken?: CancellationToken): Task;
     static extractToDirectoryAsync(source: Stream, destinationDirectoryName: string, cancellationToken?: CancellationToken): Task;
     static extractToDirectoryAsync(sourceArchiveFileName: string, destinationDirectoryName: string, overwriteFiles: boolean, cancellationToken?: CancellationToken): Task;
-    static extractToDirectoryAsync(sourceArchiveFileName: string, destinationDirectoryName: string, entryNameEncoding: Encoding, overwriteFiles: boolean, cancellationToken?: CancellationToken): Task;
-    static extractToDirectoryAsync(sourceArchiveFileName: string, destinationDirectoryName: string, entryNameEncoding: Encoding, cancellationToken?: CancellationToken): Task;
+    static extractToDirectoryAsync(sourceArchiveFileName: string, destinationDirectoryName: string, entryNameEncoding: Encoding | undefined, overwriteFiles: boolean, cancellationToken?: CancellationToken): Task;
+    static extractToDirectoryAsync(sourceArchiveFileName: string, destinationDirectoryName: string, entryNameEncoding: Encoding | undefined, cancellationToken?: CancellationToken): Task;
     static extractToDirectoryAsync(sourceArchiveFileName: string, destinationDirectoryName: string, cancellationToken?: CancellationToken): Task;
-    static open(archiveFileName: string, mode: ZipArchiveMode, entryNameEncoding: Encoding): ZipArchive;
+    static open(archiveFileName: string, mode: ZipArchiveMode, entryNameEncoding: Encoding | undefined): ZipArchive;
     static open(archiveFileName: string, mode: ZipArchiveMode): ZipArchive;
-    static openAsync(archiveFileName: string, mode: ZipArchiveMode, entryNameEncoding: Encoding, cancellationToken?: CancellationToken): Task_1<ZipArchive>;
+    static openAsync(archiveFileName: string, mode: ZipArchiveMode, entryNameEncoding: Encoding | undefined, cancellationToken?: CancellationToken): Task_1<ZipArchive>;
     static openAsync(archiveFileName: string, mode: ZipArchiveMode, cancellationToken?: CancellationToken): Task_1<ZipArchive>;
     static openRead(archiveFileName: string): ZipArchive;
     static openReadAsync(archiveFileName: string, cancellationToken?: CancellationToken): Task_1<ZipArchive>;

package/System.IO.Enumeration/internal/index.d.ts

@@ -47,21 +47,21 @@ export interface FileSystemEntry$instance {
 
 
 export const FileSystemEntry: {
-    new(): FileSystemEntry$instance;
+    new(): FileSystemEntry;
 };
 
 
 export type FileSystemEntry = FileSystemEntry$instance;
 
 export interface FileSystemEnumerable_1$instance<TResult> {
-    shouldIncludePredicate: FileSystemEnumerable_1_FindPredicate<TResult>;
-    shouldRecursePredicate: FileSystemEnumerable_1_FindPredicate<TResult>;
+    shouldIncludePredicate: FileSystemEnumerable_1_FindPredicate<TResult> | undefined;
+    shouldRecursePredicate: FileSystemEnumerable_1_FindPredicate<TResult> | undefined;
     getEnumerator(): IEnumerator_1<TResult>;
 }
 
 
 export const FileSystemEnumerable_1: {
-    new<TResult>(directory: string, transform: FileSystemEnumerable_1_FindTransform<TResult>, options: EnumerationOptions): FileSystemEnumerable_1$instance<TResult>;
+    new<TResult>(directory: string, transform: FileSystemEnumerable_1_FindTransform<TResult>, options: EnumerationOptions | undefined): FileSystemEnumerable_1<TResult>;
 };
 
 
@@ -82,7 +82,7 @@ export interface FileSystemEnumerator_1$instance<TResult> extends CriticalFinali
 
 
 export const FileSystemEnumerator_1: {
-    new<TResult>(directory: string, options: EnumerationOptions): FileSystemEnumerator_1$instance<TResult>;
+    new<TResult>(directory: string, options: EnumerationOptions | undefined): FileSystemEnumerator_1<TResult>;
 };
 
 
@@ -97,7 +97,7 @@ export type FileSystemEnumerator_1<TResult> = FileSystemEnumerator_1$instance<TR
 export abstract class FileSystemName$instance {
     static matchesSimpleExpression(expression: ReadOnlySpan_1<System_Internal.Char>, name: ReadOnlySpan_1<System_Internal.Char>, ignoreCase?: boolean): boolean;
     static matchesWin32Expression(expression: ReadOnlySpan_1<System_Internal.Char>, name: ReadOnlySpan_1<System_Internal.Char>, ignoreCase?: boolean): boolean;
-    static translateWin32Expression(expression: string): string;
+    static translateWin32Expression(expression: string | undefined): string;
 }
 
 

package/System.IO.IsolatedStorage/internal/index.d.ts

@@ -58,14 +58,14 @@ export const IsolatedStorage: {
 export type IsolatedStorage = IsolatedStorage$instance;
 
 export interface IsolatedStorageException$instance extends Exception {
-    getObjectData(info: SerializationInfo, context: StreamingContext): void;
+    getObjectData(info: SerializationInfo | undefined, context: StreamingContext): void;
 }
 
 
 export const IsolatedStorageException: {
-    new(): IsolatedStorageException$instance;
-    new(message: string): IsolatedStorageException$instance;
-    new(message: string, inner: Exception): IsolatedStorageException$instance;
+    new(): IsolatedStorageException;
+    new(message: string): IsolatedStorageException;
+    new(message: string, inner: Exception): IsolatedStorageException;
 };
 
 
@@ -110,16 +110,16 @@ export interface IsolatedStorageFile$instance extends IsolatedStorage {
 
 
 export const IsolatedStorageFile: {
-    new(): IsolatedStorageFile$instance;
+    new(): IsolatedStorageFile;
     readonly isEnabled: boolean;
     getEnumerator(scope: IsolatedStorageScope): IEnumerator;
     getMachineStoreForApplication(): IsolatedStorageFile;
     getMachineStoreForAssembly(): IsolatedStorageFile;
     getMachineStoreForDomain(): IsolatedStorageFile;
     getStore(scope: IsolatedStorageScope, domainIdentity: unknown, assemblyIdentity: unknown): IsolatedStorageFile;
-    getStore(scope: IsolatedStorageScope, applicationIdentity: unknown): IsolatedStorageFile;
+    getStore(scope: IsolatedStorageScope, applicationIdentity: unknown | undefined): IsolatedStorageFile;
     getStore(scope: IsolatedStorageScope, domainEvidenceType: Type, assemblyEvidenceType: Type): IsolatedStorageFile;
-    getStore(scope: IsolatedStorageScope, applicationEvidenceType: Type): IsolatedStorageFile;
+    getStore(scope: IsolatedStorageScope, applicationEvidenceType: Type | undefined): IsolatedStorageFile;
     getUserStoreForApplication(): IsolatedStorageFile;
     getUserStoreForAssembly(): IsolatedStorageFile;
     getUserStoreForDomain(): IsolatedStorageFile;
@@ -146,8 +146,8 @@ export interface IsolatedStorageFileStream$instance extends FileStream {
     readonly length: long;
     position: long;
     readonly safeFileHandle: SafeFileHandle;
-    beginRead(array: byte[], offset: int, numBytes: int, userCallback: AsyncCallback, stateObject: unknown): IAsyncResult;
-    beginWrite(array: byte[], offset: int, numBytes: int, userCallback: AsyncCallback, stateObject: unknown): IAsyncResult;
+    beginRead(array: byte[], offset: int, numBytes: int, userCallback: AsyncCallback | undefined, stateObject: unknown | undefined): IAsyncResult;
+    beginWrite(array: byte[], offset: int, numBytes: int, userCallback: AsyncCallback | undefined, stateObject: unknown | undefined): IAsyncResult;
     dispose(): void;
     disposeAsync(): ValueTask;
     endRead(asyncResult: IAsyncResult): int;
@@ -181,14 +181,14 @@ export interface IsolatedStorageFileStream$instance extends FileStream {
 
 
 export const IsolatedStorageFileStream: {
-    new(path: string, mode: FileMode): IsolatedStorageFileStream$instance;
-    new(path: string, mode: FileMode, isf: IsolatedStorageFile): IsolatedStorageFileStream$instance;
-    new(path: string, mode: FileMode, access: FileAccess): IsolatedStorageFileStream$instance;
-    new(path: string, mode: FileMode, access: FileAccess, isf: IsolatedStorageFile): IsolatedStorageFileStream$instance;
-    new(path: string, mode: FileMode, access: FileAccess, share: FileShare): IsolatedStorageFileStream$instance;
-    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, isf: IsolatedStorageFile): IsolatedStorageFileStream$instance;
-    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int): IsolatedStorageFileStream$instance;
-    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int, isf: IsolatedStorageFile): IsolatedStorageFileStream$instance;
+    new(path: string, mode: FileMode): IsolatedStorageFileStream;
+    new(path: string, mode: FileMode, isf: IsolatedStorageFile | undefined): IsolatedStorageFileStream;
+    new(path: string, mode: FileMode, access: FileAccess): IsolatedStorageFileStream;
+    new(path: string, mode: FileMode, access: FileAccess, isf: IsolatedStorageFile | undefined): IsolatedStorageFileStream;
+    new(path: string, mode: FileMode, access: FileAccess, share: FileShare): IsolatedStorageFileStream;
+    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, isf: IsolatedStorageFile | undefined): IsolatedStorageFileStream;
+    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int): IsolatedStorageFileStream;
+    new(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int, isf: IsolatedStorageFile | undefined): IsolatedStorageFileStream;
 };
 
 

package/System.IO.MemoryMappedFiles/internal/index.d.ts

@@ -60,17 +60,17 @@ export interface MemoryMappedFile$instance {
 
 
 export const MemoryMappedFile: {
-    new(): MemoryMappedFile$instance;
-    createFromFile(fileHandle: SafeFileHandle, mapName: string, capacity: long, access: MemoryMappedFileAccess, inheritability: HandleInheritability, leaveOpen: boolean): MemoryMappedFile;
-    createFromFile(fileStream: FileStream, mapName: string, capacity: long, access: MemoryMappedFileAccess, inheritability: HandleInheritability, leaveOpen: boolean): MemoryMappedFile;
-    createFromFile(path: string, mode: FileMode, mapName: string, capacity: long, access: MemoryMappedFileAccess): MemoryMappedFile;
-    createFromFile(path: string, mode: FileMode, mapName: string, capacity: long): MemoryMappedFile;
-    createFromFile(path: string, mode: FileMode, mapName: string): MemoryMappedFile;
+    new(): MemoryMappedFile;
+    createFromFile(fileHandle: SafeFileHandle, mapName: string | undefined, capacity: long, access: MemoryMappedFileAccess, inheritability: HandleInheritability, leaveOpen: boolean): MemoryMappedFile;
+    createFromFile(fileStream: FileStream, mapName: string | undefined, capacity: long, access: MemoryMappedFileAccess, inheritability: HandleInheritability, leaveOpen: boolean): MemoryMappedFile;
+    createFromFile(path: string, mode: FileMode, mapName: string | undefined, capacity: long, access: MemoryMappedFileAccess): MemoryMappedFile;
+    createFromFile(path: string, mode: FileMode, mapName: string | undefined, capacity: long): MemoryMappedFile;
+    createFromFile(path: string, mode: FileMode, mapName: string | undefined): MemoryMappedFile;
     createFromFile(path: string, mode: FileMode): MemoryMappedFile;
     createFromFile(path: string): MemoryMappedFile;
-    createNew(mapName: string, capacity: long, access: MemoryMappedFileAccess, options: MemoryMappedFileOptions, inheritability: HandleInheritability): MemoryMappedFile;
-    createNew(mapName: string, capacity: long, access: MemoryMappedFileAccess): MemoryMappedFile;
-    createNew(mapName: string, capacity: long): MemoryMappedFile;
+    createNew(mapName: string | undefined, capacity: long, access: MemoryMappedFileAccess, options: MemoryMappedFileOptions, inheritability: HandleInheritability): MemoryMappedFile;
+    createNew(mapName: string | undefined, capacity: long, access: MemoryMappedFileAccess): MemoryMappedFile;
+    createNew(mapName: string | undefined, capacity: long): MemoryMappedFile;
     createOrOpen(mapName: string, capacity: long, access: MemoryMappedFileAccess, options: MemoryMappedFileOptions, inheritability: HandleInheritability): MemoryMappedFile;
     createOrOpen(mapName: string, capacity: long, access: MemoryMappedFileAccess): MemoryMappedFile;
     createOrOpen(mapName: string, capacity: long): MemoryMappedFile;
@@ -98,7 +98,7 @@ export interface MemoryMappedViewAccessor$instance extends UnmanagedMemoryAccess
 
 
 export const MemoryMappedViewAccessor: {
-    new(): MemoryMappedViewAccessor$instance;
+    new(): MemoryMappedViewAccessor;
 };
 
 
@@ -120,7 +120,7 @@ export interface MemoryMappedViewStream$instance extends UnmanagedMemoryStream {
 
 
 export const MemoryMappedViewStream: {
-    new(): MemoryMappedViewStream$instance;
+    new(): MemoryMappedViewStream;
 };
 
 

package/System.IO.Pipelines/internal/index.d.ts

@@ -32,7 +32,7 @@ export interface FlushResult$instance {
 
 
 export const FlushResult: {
-    new(isCanceled: boolean, isCompleted: boolean): FlushResult$instance;
+    new(isCanceled: boolean, isCompleted: boolean): FlushResult;
 };
 
 
@@ -46,7 +46,7 @@ export interface ReadResult$instance {
 
 
 export const ReadResult: {
-    new(buffer: ReadOnlySequence_1<System_Internal.Byte>, isCanceled: boolean, isCompleted: boolean): ReadResult$instance;
+    new(buffer: ReadOnlySequence_1<System_Internal.Byte>, isCanceled: boolean, isCompleted: boolean): ReadResult;
 };
 
 
@@ -60,8 +60,8 @@ export interface Pipe$instance {
 
 
 export const Pipe: {
-    new(): Pipe$instance;
-    new(options: PipeOptions): Pipe$instance;
+    new(): Pipe;
+    new(options: PipeOptions): Pipe;
 };
 
 
@@ -79,7 +79,7 @@ export interface PipeOptions$instance {
 
 
 export const PipeOptions: {
-    new(pool: MemoryPool_1<System_Internal.Byte>, readerScheduler: PipeScheduler, writerScheduler: PipeScheduler, pauseWriterThreshold: long, resumeWriterThreshold: long, minimumSegmentSize: int, useSynchronizationContext: boolean): PipeOptions$instance;
+    new(pool: MemoryPool_1<System_Internal.Byte>, readerScheduler: PipeScheduler, writerScheduler: PipeScheduler, pauseWriterThreshold: long, resumeWriterThreshold: long, minimumSegmentSize: int, useSynchronizationContext: boolean): PipeOptions;
     readonly default_: PipeOptions;
 };
 
@@ -95,7 +95,7 @@ export interface PipeReader$instance {
     completeAsync(exception?: Exception): ValueTask;
     copyToAsync(destination: PipeWriter, cancellationToken?: CancellationToken): Task;
     copyToAsync(destination: Stream, cancellationToken?: CancellationToken): Task;
-    onWriterCompleted(callback: Action_2<Exception, unknown>, state: unknown): void;
+    onWriterCompleted(callback: Action_2<Exception | undefined, unknown | undefined>, state: unknown): void;
     readAsync(cancellationToken?: CancellationToken): ValueTask_1<ReadResult>;
     readAtLeastAsync(minimumSize: int, cancellationToken?: CancellationToken): ValueTask_1<ReadResult>;
     tryRead(result: ReadResult): boolean;
@@ -104,14 +104,14 @@ export interface PipeReader$instance {
 
 export const PipeReader: {
     create(sequence: ReadOnlySequence_1<System_Internal.Byte>): PipeReader;
-    create(stream: Stream, readerOptions?: StreamPipeReaderOptions): PipeReader;
+    create(stream: Stream, readerOptions?: StreamPipeReaderOptions | undefined): PipeReader;
 };
 
 
 export type PipeReader = PipeReader$instance;
 
 export interface PipeScheduler$instance {
-    schedule(action: Action_1<unknown>, state: unknown): void;
+    schedule(action: Action_1<unknown | undefined>, state: unknown): void;
 }
 
 
@@ -134,13 +134,13 @@ export interface PipeWriter$instance {
     flushAsync(cancellationToken?: CancellationToken): ValueTask_1<FlushResult>;
     getMemory(sizeHint?: int): Memory_1<System_Internal.Byte>;
     getSpan(sizeHint?: int): Span_1<System_Internal.Byte>;
-    onReaderCompleted(callback: Action_2<Exception, unknown>, state: unknown): void;
+    onReaderCompleted(callback: Action_2<Exception | undefined, unknown | undefined>, state: unknown): void;
     writeAsync(source: ReadOnlyMemory_1<System_Internal.Byte>, cancellationToken?: CancellationToken): ValueTask_1<FlushResult>;
 }
 
 
 export const PipeWriter: {
-    create(stream: Stream, writerOptions?: StreamPipeWriterOptions): PipeWriter;
+    create(stream: Stream, writerOptions?: StreamPipeWriterOptions | undefined): PipeWriter;
 };
 
 
@@ -163,8 +163,8 @@ export interface StreamPipeReaderOptions$instance {
 
 
 export const StreamPipeReaderOptions: {
-    new(pool: MemoryPool_1<System_Internal.Byte>, bufferSize: int, minimumReadSize: int, leaveOpen: boolean): StreamPipeReaderOptions$instance;
-    new(pool: MemoryPool_1<System_Internal.Byte>, bufferSize: int, minimumReadSize: int, leaveOpen: boolean, useZeroByteReads: boolean): StreamPipeReaderOptions$instance;
+    new(pool: MemoryPool_1<System_Internal.Byte>, bufferSize: int, minimumReadSize: int, leaveOpen: boolean): StreamPipeReaderOptions;
+    new(pool: MemoryPool_1<System_Internal.Byte>, bufferSize: int, minimumReadSize: int, leaveOpen: boolean, useZeroByteReads: boolean): StreamPipeReaderOptions;
 };
 
 
@@ -178,7 +178,7 @@ export interface StreamPipeWriterOptions$instance {
 
 
 export const StreamPipeWriterOptions: {
-    new(pool: MemoryPool_1<System_Internal.Byte>, minimumBufferSize: int, leaveOpen: boolean): StreamPipeWriterOptions$instance;
+    new(pool: MemoryPool_1<System_Internal.Byte>, minimumBufferSize: int, leaveOpen: boolean): StreamPipeWriterOptions;
 };
 
 

package/System.IO.Pipes/internal/index.d.ts

@@ -75,9 +75,9 @@ export interface AnonymousPipeClientStream$instance extends PipeStream$instance
 
 
 export const AnonymousPipeClientStream: {
-    new(pipeHandleAsString: string): AnonymousPipeClientStream$instance;
-    new(direction: PipeDirection, pipeHandleAsString: string): AnonymousPipeClientStream$instance;
-    new(direction: PipeDirection, safePipeHandle: SafePipeHandle): AnonymousPipeClientStream$instance;
+    new(pipeHandleAsString: string): AnonymousPipeClientStream;
+    new(direction: PipeDirection, pipeHandleAsString: string): AnonymousPipeClientStream;
+    new(direction: PipeDirection, safePipeHandle: SafePipeHandle): AnonymousPipeClientStream;
 };
 
 
@@ -101,11 +101,11 @@ export interface AnonymousPipeServerStream$instance extends PipeStream$instance
 
 
 export const AnonymousPipeServerStream: {
-    new(): AnonymousPipeServerStream$instance;
-    new(direction: PipeDirection): AnonymousPipeServerStream$instance;
-    new(direction: PipeDirection, inheritability: HandleInheritability): AnonymousPipeServerStream$instance;
-    new(direction: PipeDirection, serverSafePipeHandle: SafePipeHandle, clientSafePipeHandle: SafePipeHandle): AnonymousPipeServerStream$instance;
-    new(direction: PipeDirection, inheritability: HandleInheritability, bufferSize: int): AnonymousPipeServerStream$instance;
+    new(): AnonymousPipeServerStream;
+    new(direction: PipeDirection): AnonymousPipeServerStream;
+    new(direction: PipeDirection, inheritability: HandleInheritability): AnonymousPipeServerStream;
+    new(direction: PipeDirection, serverSafePipeHandle: SafePipeHandle, clientSafePipeHandle: SafePipeHandle): AnonymousPipeServerStream;
+    new(direction: PipeDirection, inheritability: HandleInheritability, bufferSize: int): AnonymousPipeServerStream;
 };
 
 
@@ -135,14 +135,14 @@ export interface NamedPipeClientStream$instance extends PipeStream$instance {
 
 
 export const NamedPipeClientStream: {
-    new(pipeName: string): NamedPipeClientStream$instance;
-    new(serverName: string, pipeName: string): NamedPipeClientStream$instance;
-    new(serverName: string, pipeName: string, direction: PipeDirection): NamedPipeClientStream$instance;
-    new(serverName: string, pipeName: string, direction: PipeDirection, options: PipeOptions): NamedPipeClientStream$instance;
-    new(serverName: string, pipeName: string, direction: PipeDirection, options: PipeOptions, impersonationLevel: TokenImpersonationLevel): NamedPipeClientStream$instance;
-    new(serverName: string, pipeName: string, direction: PipeDirection, options: PipeOptions, impersonationLevel: TokenImpersonationLevel, inheritability: HandleInheritability): NamedPipeClientStream$instance;
-    new(direction: PipeDirection, isAsync: boolean, isConnected: boolean, safePipeHandle: SafePipeHandle): NamedPipeClientStream$instance;
-    new(serverName: string, pipeName: string, desiredAccessRights: PipeAccessRights, options: PipeOptions, impersonationLevel: TokenImpersonationLevel, inheritability: HandleInheritability): NamedPipeClientStream$instance;
+    new(pipeName: string): NamedPipeClientStream;
+    new(serverName: string, pipeName: string): NamedPipeClientStream;
+    new(serverName: string, pipeName: string, direction: PipeDirection): NamedPipeClientStream;
+    new(serverName: string, pipeName: string, direction: PipeDirection, options: PipeOptions): NamedPipeClientStream;
+    new(serverName: string, pipeName: string, direction: PipeDirection, options: PipeOptions, impersonationLevel: TokenImpersonationLevel): NamedPipeClientStream;
+    new(serverName: string, pipeName: string, direction: PipeDirection, options: PipeOptions, impersonationLevel: TokenImpersonationLevel, inheritability: HandleInheritability): NamedPipeClientStream;
+    new(direction: PipeDirection, isAsync: boolean, isConnected: boolean, safePipeHandle: SafePipeHandle): NamedPipeClientStream;
+    new(serverName: string, pipeName: string, desiredAccessRights: PipeAccessRights, options: PipeOptions, impersonationLevel: TokenImpersonationLevel, inheritability: HandleInheritability): NamedPipeClientStream;
 };
 
 
@@ -171,13 +171,13 @@ export interface NamedPipeServerStream$instance extends PipeStream$instance {
 
 
 export const NamedPipeServerStream: {
-    new(pipeName: string): NamedPipeServerStream$instance;
-    new(pipeName: string, direction: PipeDirection): NamedPipeServerStream$instance;
-    new(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int): NamedPipeServerStream$instance;
-    new(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int, transmissionMode: PipeTransmissionMode): NamedPipeServerStream$instance;
-    new(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int, transmissionMode: PipeTransmissionMode, options: PipeOptions): NamedPipeServerStream$instance;
-    new(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int, transmissionMode: PipeTransmissionMode, options: PipeOptions, inBufferSize: int, outBufferSize: int): NamedPipeServerStream$instance;
-    new(direction: PipeDirection, isAsync: boolean, isConnected: boolean, safePipeHandle: SafePipeHandle): NamedPipeServerStream$instance;
+    new(pipeName: string): NamedPipeServerStream;
+    new(pipeName: string, direction: PipeDirection): NamedPipeServerStream;
+    new(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int): NamedPipeServerStream;
+    new(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int, transmissionMode: PipeTransmissionMode): NamedPipeServerStream;
+    new(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int, transmissionMode: PipeTransmissionMode, options: PipeOptions): NamedPipeServerStream;
+    new(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int, transmissionMode: PipeTransmissionMode, options: PipeOptions, inBufferSize: int, outBufferSize: int): NamedPipeServerStream;
+    new(direction: PipeDirection, isAsync: boolean, isConnected: boolean, safePipeHandle: SafePipeHandle): NamedPipeServerStream;
     readonly maxAllowedServerInstances: int;
 };
 
@@ -196,8 +196,8 @@ export interface PipeAccessRule$instance extends AccessRule {
 
 
 export const PipeAccessRule: {
-    new(identity: IdentityReference, rights: PipeAccessRights, type_: AccessControlType): PipeAccessRule$instance;
-    new(identity: string, rights: PipeAccessRights, type_: AccessControlType): PipeAccessRule$instance;
+    new(identity: IdentityReference, rights: PipeAccessRights, type_: AccessControlType): PipeAccessRule;
+    new(identity: string, rights: PipeAccessRights, type_: AccessControlType): PipeAccessRule;
 };
 
 
@@ -209,8 +209,8 @@ export interface PipeAuditRule$instance extends AuditRule {
 
 
 export const PipeAuditRule: {
-    new(identity: IdentityReference, rights: PipeAccessRights, flags: AuditFlags): PipeAuditRule$instance;
-    new(identity: string, rights: PipeAccessRights, flags: AuditFlags): PipeAuditRule$instance;
+    new(identity: IdentityReference, rights: PipeAccessRights, flags: AuditFlags): PipeAuditRule;
+    new(identity: string, rights: PipeAccessRights, flags: AuditFlags): PipeAuditRule;
 };
 
 
@@ -236,7 +236,7 @@ export interface PipeSecurity$instance extends NativeObjectSecurity {
 
 
 export const PipeSecurity: {
-    new(): PipeSecurity$instance;
+    new(): PipeSecurity;
 };
 
 
@@ -256,8 +256,8 @@ export interface PipeStream$instance extends Stream {
     readMode: PipeTransmissionMode;
     readonly safePipeHandle: SafePipeHandle;
     readonly transmissionMode: PipeTransmissionMode;
-    beginRead(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
-    beginWrite(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
+    beginRead(buffer: byte[], offset: int, count: int, callback: AsyncCallback | undefined, state: unknown | undefined): IAsyncResult;
+    beginWrite(buffer: byte[], offset: int, count: int, callback: AsyncCallback | undefined, state: unknown | undefined): IAsyncResult;
     dispose(): void;
     disposeAsync(): ValueTask;
     endRead(asyncResult: IAsyncResult): int;
@@ -301,14 +301,14 @@ export type PipeStream = PipeStream$instance & __PipeStream$views;
 
 
 export abstract class AnonymousPipeServerStreamAcl$instance {
-    static create(direction: PipeDirection, inheritability: HandleInheritability, bufferSize: int, pipeSecurity: PipeSecurity): AnonymousPipeServerStream;
+    static create(direction: PipeDirection, inheritability: HandleInheritability, bufferSize: int, pipeSecurity: PipeSecurity | undefined): AnonymousPipeServerStream;
 }
 
 
 export type AnonymousPipeServerStreamAcl = AnonymousPipeServerStreamAcl$instance;
 
 export abstract class NamedPipeServerStreamAcl$instance {
-    static create(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int, transmissionMode: PipeTransmissionMode, options: PipeOptions, inBufferSize: int, outBufferSize: int, pipeSecurity: PipeSecurity, inheritability?: HandleInheritability, additionalAccessRights?: PipeAccessRights): NamedPipeServerStream;
+    static create(pipeName: string, direction: PipeDirection, maxNumberOfServerInstances: int, transmissionMode: PipeTransmissionMode, options: PipeOptions, inBufferSize: int, outBufferSize: int, pipeSecurity: PipeSecurity | undefined, inheritability?: HandleInheritability, additionalAccessRights?: PipeAccessRights): NamedPipeServerStream;
 }