@tsonic/dotnet 0.8.0 → 0.8.2

package/System.Threading/internal/index.d.ts

@@ -129,7 +129,7 @@ export interface AsyncFlowControl$instance {
 
 
 export const AsyncFlowControl: {
-    new(): AsyncFlowControl$instance;
+    new(): AsyncFlowControl;
 };
 
 
@@ -147,14 +147,14 @@ export type AsyncFlowControl = AsyncFlowControl$instance & __AsyncFlowControl$vi
 
 
 export interface AsyncLocalValueChangedArgs_1$instance<T> {
-    readonly currentValue: T;
-    readonly previousValue: T;
+    readonly currentValue: T | undefined;
+    readonly previousValue: T | undefined;
     readonly threadContextChanged: boolean;
 }
 
 
 export const AsyncLocalValueChangedArgs_1: {
-    new<T>(): AsyncLocalValueChangedArgs_1$instance<T>;
+    new<T>(): AsyncLocalValueChangedArgs_1<T>;
 };
 
 
@@ -165,21 +165,21 @@ export interface CancellationToken$instance {
     readonly isCancellationRequested: boolean;
     readonly waitHandle: WaitHandle;
     equals(other: CancellationToken): boolean;
-    equals(other: unknown): boolean;
+    equals(other: unknown | undefined): boolean;
     getHashCode(): int;
-    register(callback: Action): CancellationTokenRegistration;
-    register(callback: Action, useSynchronizationContext: boolean): CancellationTokenRegistration;
-    register(callback: Action_1<unknown>, state: unknown): CancellationTokenRegistration;
-    register(callback: Action_2<unknown, CancellationToken>, state: unknown): CancellationTokenRegistration;
-    register(callback: Action_1<unknown>, state: unknown, useSynchronizationContext: boolean): CancellationTokenRegistration;
+    register(callback: Action | undefined): CancellationTokenRegistration;
+    register(callback: Action | undefined, useSynchronizationContext: boolean): CancellationTokenRegistration;
+    register(callback: Action_1<unknown | undefined>, state: unknown | undefined): CancellationTokenRegistration;
+    register(callback: Action_2<unknown | undefined, CancellationToken>, state: unknown | undefined): CancellationTokenRegistration;
+    register(callback: Action_1<unknown | undefined>, state: unknown | undefined, useSynchronizationContext: boolean): CancellationTokenRegistration;
     throwIfCancellationRequested(): void;
-    unsafeRegister(callback: Action_1<unknown>, state: unknown): CancellationTokenRegistration;
-    unsafeRegister(callback: Action_2<unknown, CancellationToken>, state: unknown): CancellationTokenRegistration;
+    unsafeRegister(callback: Action_1<unknown | undefined>, state: unknown | undefined): CancellationTokenRegistration;
+    unsafeRegister(callback: Action_2<unknown | undefined, CancellationToken>, state: unknown | undefined): CancellationTokenRegistration;
 }
 
 
 export const CancellationToken: {
-    new(canceled: boolean): CancellationToken$instance;
+    new(canceled: boolean): CancellationToken;
     readonly none: CancellationToken;
 };
 
@@ -206,7 +206,7 @@ export interface CancellationTokenRegistration$instance {
 
 
 export const CancellationTokenRegistration: {
-    new(): CancellationTokenRegistration$instance;
+    new(): CancellationTokenRegistration;
 };
 
 
@@ -230,7 +230,7 @@ export interface Lock_Scope$instance {
 
 
 export const Lock_Scope: {
-    new(): Lock_Scope$instance;
+    new(): Lock_Scope;
 };
 
 
@@ -244,7 +244,7 @@ export interface LockCookie$instance {
 
 
 export const LockCookie: {
-    new(): LockCookie$instance;
+    new(): LockCookie;
 };
 
 
@@ -265,7 +265,7 @@ export interface NamedWaitHandleOptions$instance {
 
 
 export const NamedWaitHandleOptions: {
-    new(): NamedWaitHandleOptions$instance;
+    new(): NamedWaitHandleOptions;
 };
 
 
@@ -281,7 +281,7 @@ export interface NativeOverlapped$instance {
 
 
 export const NativeOverlapped: {
-    new(): NativeOverlapped$instance;
+    new(): NativeOverlapped;
 };
 
 
@@ -301,7 +301,7 @@ export interface SpinLock$instance {
 
 
 export const SpinLock: {
-    new(enableThreadOwnerTracking: boolean): SpinLock$instance;
+    new(enableThreadOwnerTracking: boolean): SpinLock;
 };
 
 
@@ -317,7 +317,7 @@ export interface SpinWait$instance {
 
 
 export const SpinWait: {
-    new(): SpinWait$instance;
+    new(): SpinWait;
     spinUntil(condition: Func_1<System_Internal.Boolean>, millisecondsTimeout: int): boolean;
     spinUntil(condition: Func_1<System_Internal.Boolean>, timeout: TimeSpan): boolean;
     spinUntil(condition: Func_1<System_Internal.Boolean>): void;
@@ -327,19 +327,19 @@ export const SpinWait: {
 export type SpinWait = SpinWait$instance;
 
 export interface AbandonedMutexException$instance extends SystemException {
-    readonly mutex: Mutex;
+    readonly mutex: Mutex | undefined;
     readonly mutexIndex: int;
     getObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
 
 export const AbandonedMutexException: {
-    new(): AbandonedMutexException$instance;
-    new(message: string): AbandonedMutexException$instance;
-    new(message: string, inner: Exception): AbandonedMutexException$instance;
-    new(location: int, handle: WaitHandle): AbandonedMutexException$instance;
-    new(message: string, location: int, handle: WaitHandle): AbandonedMutexException$instance;
-    new(message: string, inner: Exception, location: int, handle: WaitHandle): AbandonedMutexException$instance;
+    new(): AbandonedMutexException;
+    new(message: string | undefined): AbandonedMutexException;
+    new(message: string | undefined, inner: Exception | undefined): AbandonedMutexException;
+    new(location: int, handle: WaitHandle | undefined): AbandonedMutexException;
+    new(message: string | undefined, location: int, handle: WaitHandle | undefined): AbandonedMutexException;
+    new(message: string | undefined, inner: Exception | undefined, location: int, handle: WaitHandle | undefined): AbandonedMutexException;
 };
 
 
@@ -356,8 +356,8 @@ export interface AsyncLocal_1$instance<T> {
 
 
 export const AsyncLocal_1: {
-    new<T>(): AsyncLocal_1$instance<T>;
-    new<T>(valueChangedHandler: Action_1<AsyncLocalValueChangedArgs_1<T>>): AsyncLocal_1$instance<T>;
+    new<T>(): AsyncLocal_1<T>;
+    new<T>(valueChangedHandler: Action_1<AsyncLocalValueChangedArgs_1<T>> | undefined): AsyncLocal_1<T>;
 };
 
 
@@ -369,7 +369,7 @@ export interface AutoResetEvent$instance extends EventWaitHandle$instance {
 
 
 export const AutoResetEvent: {
-    new(initialState: boolean): AutoResetEvent$instance;
+    new(initialState: boolean): AutoResetEvent;
 };
 
 
@@ -399,8 +399,8 @@ export interface Barrier$instance {
 
 
 export const Barrier: {
-    new(participantCount: int): Barrier$instance;
-    new(participantCount: int, postPhaseAction: Action_1<Barrier>): Barrier$instance;
+    new(participantCount: int): Barrier;
+    new(participantCount: int, postPhaseAction: Action_1<Barrier> | undefined): Barrier;
 };
 
 
@@ -414,15 +414,15 @@ export type Barrier = Barrier$instance & __Barrier$views;
 
 
 export interface BarrierPostPhaseException$instance extends Exception {
-    getObjectData(info: SerializationInfo, context: StreamingContext): void;
+    getObjectData(info: SerializationInfo | undefined, context: StreamingContext): void;
 }
 
 
 export const BarrierPostPhaseException: {
-    new(): BarrierPostPhaseException$instance;
-    new(innerException: Exception): BarrierPostPhaseException$instance;
-    new(message: string): BarrierPostPhaseException$instance;
-    new(message: string, innerException: Exception): BarrierPostPhaseException$instance;
+    new(): BarrierPostPhaseException;
+    new(innerException: Exception | undefined): BarrierPostPhaseException;
+    new(message: string | undefined): BarrierPostPhaseException;
+    new(message: string | undefined, innerException: Exception | undefined): BarrierPostPhaseException;
 };
 
 
@@ -447,10 +447,10 @@ export interface CancellationTokenSource$instance {
 
 
 export const CancellationTokenSource: {
-    new(): CancellationTokenSource$instance;
-    new(delay: TimeSpan): CancellationTokenSource$instance;
-    new(delay: TimeSpan, timeProvider: TimeProvider): CancellationTokenSource$instance;
-    new(millisecondsDelay: int): CancellationTokenSource$instance;
+    new(): CancellationTokenSource;
+    new(delay: TimeSpan): CancellationTokenSource;
+    new(delay: TimeSpan, timeProvider: TimeProvider): CancellationTokenSource;
+    new(millisecondsDelay: int): CancellationTokenSource;
     createLinkedTokenSource(tokens: ReadOnlySpan_1<CancellationToken>): CancellationTokenSource;
     createLinkedTokenSource(token1: CancellationToken, token2: CancellationToken): CancellationTokenSource;
     createLinkedTokenSource(token: CancellationToken): CancellationTokenSource;
@@ -474,10 +474,10 @@ export interface CompressedStack$instance {
 
 
 export const CompressedStack: {
-    new(): CompressedStack$instance;
+    new(): CompressedStack;
     capture(): CompressedStack;
     getCompressedStack(): CompressedStack;
-    run(compressedStack: CompressedStack, callback: ContextCallback, state: unknown): void;
+    run(compressedStack: CompressedStack, callback: ContextCallback, state: unknown | undefined): void;
 };
 
 
@@ -514,7 +514,7 @@ export interface CountdownEvent$instance {
 
 
 export const CountdownEvent: {
-    new(initialCount: int): CountdownEvent$instance;
+    new(initialCount: int): CountdownEvent;
 };
 
 
@@ -535,15 +535,15 @@ export interface EventWaitHandle$instance extends WaitHandle$instance {
 
 
 export const EventWaitHandle: {
-    new(initialState: boolean, mode: EventResetMode): EventWaitHandle$instance;
-    new(initialState: boolean, mode: EventResetMode, name: string, options: NamedWaitHandleOptions): EventWaitHandle$instance;
-    new(initialState: boolean, mode: EventResetMode, name: string): EventWaitHandle$instance;
-    new(initialState: boolean, mode: EventResetMode, name: string, options: NamedWaitHandleOptions, createdNew: boolean): EventWaitHandle$instance;
-    new(initialState: boolean, mode: EventResetMode, name: string, createdNew: boolean): EventWaitHandle$instance;
+    new(initialState: boolean, mode: EventResetMode): EventWaitHandle;
+    new(initialState: boolean, mode: EventResetMode, name: string, options: NamedWaitHandleOptions): EventWaitHandle;
+    new(initialState: boolean, mode: EventResetMode, name: string): EventWaitHandle;
+    new(initialState: boolean, mode: EventResetMode, name: string, options: NamedWaitHandleOptions, createdNew: boolean): EventWaitHandle;
+    new(initialState: boolean, mode: EventResetMode, name: string, createdNew: boolean): EventWaitHandle;
     openExisting(name: string, options: NamedWaitHandleOptions): EventWaitHandle;
     openExisting(name: string): EventWaitHandle;
-    tryOpenExisting(name: string, result: EventWaitHandle): boolean;
-    tryOpenExisting(name: string, options: NamedWaitHandleOptions, result: EventWaitHandle): boolean;
+    tryOpenExisting(name: string, result: EventWaitHandle | undefined): boolean;
+    tryOpenExisting(name: string, options: NamedWaitHandleOptions, result: EventWaitHandle | undefined): boolean;
 };
 
 
@@ -562,12 +562,12 @@ export interface ExecutionContext$instance {
 
 
 export const ExecutionContext: {
-    new(): ExecutionContext$instance;
+    new(): ExecutionContext;
     capture(): ExecutionContext;
     isFlowSuppressed(): boolean;
     restore(executionContext: ExecutionContext): void;
     restoreFlow(): void;
-    run(executionContext: ExecutionContext, callback: ContextCallback, state: unknown): void;
+    run(executionContext: ExecutionContext, callback: ContextCallback, state: unknown | undefined): void;
     suppressFlow(): AsyncFlowControl;
 };
 
@@ -590,8 +590,8 @@ export interface HostExecutionContext$instance {
 
 
 export const HostExecutionContext: {
-    new(): HostExecutionContext$instance;
-    new(state: unknown): HostExecutionContext$instance;
+    new(): HostExecutionContext;
+    new(state: unknown | undefined): HostExecutionContext;
 };
 
 
@@ -610,7 +610,7 @@ export interface HostExecutionContextManager$instance {
 
 
 export const HostExecutionContextManager: {
-    new(): HostExecutionContextManager$instance;
+    new(): HostExecutionContextManager;
 };
 
 
@@ -628,21 +628,21 @@ export interface Lock$instance {
 
 
 export const Lock: {
-    new(): Lock$instance;
+    new(): Lock;
 };
 
 
 export type Lock = Lock$instance;
 
 export interface LockRecursionException$instance extends Exception {
-    getObjectData(info: SerializationInfo, context: StreamingContext): void;
+    getObjectData(info: SerializationInfo | undefined, context: StreamingContext): void;
 }
 
 
 export const LockRecursionException: {
-    new(): LockRecursionException$instance;
-    new(message: string): LockRecursionException$instance;
-    new(message: string, innerException: Exception): LockRecursionException$instance;
+    new(): LockRecursionException;
+    new(message: string | undefined): LockRecursionException;
+    new(message: string | undefined, innerException: Exception | undefined): LockRecursionException;
 };
 
 
@@ -659,7 +659,7 @@ export interface ManualResetEvent$instance extends EventWaitHandle$instance {
 
 
 export const ManualResetEvent: {
-    new(initialState: boolean): ManualResetEvent$instance;
+    new(initialState: boolean): ManualResetEvent;
 };
 
 
@@ -687,9 +687,9 @@ export interface ManualResetEventSlim$instance {
 
 
 export const ManualResetEventSlim: {
-    new(): ManualResetEventSlim$instance;
-    new(initialState: boolean): ManualResetEventSlim$instance;
-    new(initialState: boolean, spinCount: int): ManualResetEventSlim$instance;
+    new(): ManualResetEventSlim;
+    new(initialState: boolean): ManualResetEventSlim;
+    new(initialState: boolean, spinCount: int): ManualResetEventSlim;
 };
 
 
@@ -709,17 +709,17 @@ export interface Mutex$instance extends WaitHandle$instance {
 
 
 export const Mutex: {
-    new(initiallyOwned: boolean, name: string, options: NamedWaitHandleOptions, createdNew: boolean): Mutex$instance;
-    new(initiallyOwned: boolean, name: string, createdNew: boolean): Mutex$instance;
-    new(initiallyOwned: boolean, name: string, options: NamedWaitHandleOptions): Mutex$instance;
-    new(initiallyOwned: boolean, name: string): Mutex$instance;
-    new(name: string, options: NamedWaitHandleOptions): Mutex$instance;
-    new(initiallyOwned: boolean): Mutex$instance;
-    new(): Mutex$instance;
-    openExisting(name: string, options: NamedWaitHandleOptions): Mutex;
-    openExisting(name: string): Mutex;
-    tryOpenExisting(name: string, result: Mutex): boolean;
-    tryOpenExisting(name: string, options: NamedWaitHandleOptions, result: Mutex): boolean;
+    new(initiallyOwned: boolean, name: string | undefined, options: NamedWaitHandleOptions, createdNew: boolean): Mutex;
+    new(initiallyOwned: boolean, name: string | undefined, createdNew: boolean): Mutex;
+    new(initiallyOwned: boolean, name: string | undefined, options: NamedWaitHandleOptions): Mutex;
+    new(initiallyOwned: boolean, name: string | undefined): Mutex;
+    new(name: string | undefined, options: NamedWaitHandleOptions): Mutex;
+    new(initiallyOwned: boolean): Mutex;
+    new(): Mutex;
+    openExisting(name: string | undefined, options: NamedWaitHandleOptions): Mutex | undefined;
+    openExisting(name: string | undefined): Mutex | undefined;
+    tryOpenExisting(name: string | undefined, result: Mutex | undefined): boolean;
+    tryOpenExisting(name: string | undefined, options: NamedWaitHandleOptions, result: Mutex | undefined): boolean;
 };
 
 
@@ -736,17 +736,17 @@ export interface Overlapped$instance {
     eventHandleIntPtr: nint;
     offsetHigh: int;
     offsetLow: int;
-    pack(iocb: IOCompletionCallback): ptr<NativeOverlapped>;
+    pack(iocb: IOCompletionCallback | undefined): ptr<NativeOverlapped>;
     pack(iocb: IOCompletionCallback, userData: unknown): ptr<NativeOverlapped>;
-    unsafePack(iocb: IOCompletionCallback): ptr<NativeOverlapped>;
+    unsafePack(iocb: IOCompletionCallback | undefined): ptr<NativeOverlapped>;
     unsafePack(iocb: IOCompletionCallback, userData: unknown): ptr<NativeOverlapped>;
 }
 
 
 export const Overlapped: {
-    new(): Overlapped$instance;
-    new(offsetLo: int, offsetHi: int, hEvent: nint, ar: IAsyncResult): Overlapped$instance;
-    new(offsetLo: int, offsetHi: int, hEvent: int, ar: IAsyncResult): Overlapped$instance;
+    new(): Overlapped;
+    new(offsetLo: int, offsetHi: int, hEvent: nint, ar: IAsyncResult): Overlapped;
+    new(offsetLo: int, offsetHi: int, hEvent: int, ar: IAsyncResult): Overlapped;
     free(nativeOverlappedPtr: ptr<NativeOverlapped>): void;
     unpack(nativeOverlappedPtr: ptr<NativeOverlapped>): Overlapped;
 };
@@ -762,8 +762,8 @@ export interface PeriodicTimer$instance {
 
 
 export const PeriodicTimer: {
-    new(period: TimeSpan): PeriodicTimer$instance;
-    new(period: TimeSpan, timeProvider: TimeProvider): PeriodicTimer$instance;
+    new(period: TimeSpan): PeriodicTimer;
+    new(period: TimeSpan, timeProvider: TimeProvider): PeriodicTimer;
 };
 
 
@@ -782,8 +782,8 @@ export interface PreAllocatedOverlapped$instance {
 
 
 export const PreAllocatedOverlapped: {
-    new(callback: IOCompletionCallback, state: unknown, pinData: unknown): PreAllocatedOverlapped$instance;
-    unsafeCreate(callback: IOCompletionCallback, state: unknown, pinData: unknown): PreAllocatedOverlapped;
+    new(callback: IOCompletionCallback, state: unknown, pinData: unknown): PreAllocatedOverlapped;
+    unsafeCreate(callback: IOCompletionCallback, state: unknown | undefined, pinData: unknown | undefined): PreAllocatedOverlapped;
 };
 
 
@@ -816,7 +816,7 @@ export interface ReaderWriterLock$instance extends CriticalFinalizerObject {
 
 
 export const ReaderWriterLock: {
-    new(): ReaderWriterLock$instance;
+    new(): ReaderWriterLock;
 };
 
 
@@ -851,8 +851,8 @@ export interface ReaderWriterLockSlim$instance {
 
 
 export const ReaderWriterLockSlim: {
-    new(): ReaderWriterLockSlim$instance;
-    new(recursionPolicy: LockRecursionPolicy): ReaderWriterLockSlim$instance;
+    new(): ReaderWriterLockSlim;
+    new(recursionPolicy: LockRecursionPolicy): ReaderWriterLockSlim;
 };
 
 
@@ -866,12 +866,12 @@ export type ReaderWriterLockSlim = ReaderWriterLockSlim$instance & __ReaderWrite
 
 
 export interface RegisteredWaitHandle$instance extends MarshalByRefObject {
-    unregister(waitObject: WaitHandle): boolean;
+    unregister(waitObject: WaitHandle | undefined): boolean;
 }
 
 
 export const RegisteredWaitHandle: {
-    new(): RegisteredWaitHandle$instance;
+    new(): RegisteredWaitHandle;
 };
 
 
@@ -885,15 +885,15 @@ export interface Semaphore$instance extends WaitHandle$instance {
 
 
 export const Semaphore: {
-    new(initialCount: int, maximumCount: int): Semaphore$instance;
-    new(initialCount: int, maximumCount: int, name: string, options: NamedWaitHandleOptions): Semaphore$instance;
-    new(initialCount: int, maximumCount: int, name: string): Semaphore$instance;
-    new(initialCount: int, maximumCount: int, name: string, options: NamedWaitHandleOptions, createdNew: boolean): Semaphore$instance;
-    new(initialCount: int, maximumCount: int, name: string, createdNew: boolean): Semaphore$instance;
+    new(initialCount: int, maximumCount: int): Semaphore;
+    new(initialCount: int, maximumCount: int, name: string, options: NamedWaitHandleOptions): Semaphore;
+    new(initialCount: int, maximumCount: int, name: string): Semaphore;
+    new(initialCount: int, maximumCount: int, name: string, options: NamedWaitHandleOptions, createdNew: boolean): Semaphore;
+    new(initialCount: int, maximumCount: int, name: string, createdNew: boolean): Semaphore;
     openExisting(name: string, options: NamedWaitHandleOptions): Semaphore;
     openExisting(name: string): Semaphore;
-    tryOpenExisting(name: string, options: NamedWaitHandleOptions, result: Semaphore): boolean;
-    tryOpenExisting(name: string, result: Semaphore): boolean;
+    tryOpenExisting(name: string, options: NamedWaitHandleOptions, result: Semaphore | undefined): boolean;
+    tryOpenExisting(name: string, result: Semaphore | undefined): boolean;
 };
 
 
@@ -910,9 +910,9 @@ export interface SemaphoreFullException$instance extends SystemException {
 
 
 export const SemaphoreFullException: {
-    new(): SemaphoreFullException$instance;
-    new(message: string): SemaphoreFullException$instance;
-    new(message: string, innerException: Exception): SemaphoreFullException$instance;
+    new(): SemaphoreFullException;
+    new(message: string | undefined): SemaphoreFullException;
+    new(message: string | undefined, innerException: Exception | undefined): SemaphoreFullException;
 };
 
 
@@ -945,8 +945,8 @@ export interface SemaphoreSlim$instance {
 
 
 export const SemaphoreSlim: {
-    new(initialCount: int): SemaphoreSlim$instance;
-    new(initialCount: int, maxCount: int): SemaphoreSlim$instance;
+    new(initialCount: int): SemaphoreSlim;
+    new(initialCount: int, maxCount: int): SemaphoreSlim;
 };
 
 
@@ -964,15 +964,15 @@ export interface SynchronizationContext$instance {
     isWaitNotificationRequired(): boolean;
     operationCompleted(): void;
     operationStarted(): void;
-    post(d: SendOrPostCallback, state: unknown): void;
-    send(d: SendOrPostCallback, state: unknown): void;
+    post(d: SendOrPostCallback, state: unknown | undefined): void;
+    send(d: SendOrPostCallback, state: unknown | undefined): void;
     wait(waitHandles: nint[], waitAll: boolean, millisecondsTimeout: int): int;
 }
 
 
 export const SynchronizationContext: {
-    new(): SynchronizationContext$instance;
-    readonly current: SynchronizationContext;
+    new(): SynchronizationContext;
+    readonly current: SynchronizationContext | undefined;
     setSynchronizationContext(syncContext: SynchronizationContext): void;
 };
 
@@ -985,9 +985,9 @@ export interface SynchronizationLockException$instance extends SystemException {
 
 
 export const SynchronizationLockException: {
-    new(): SynchronizationLockException$instance;
-    new(message: string): SynchronizationLockException$instance;
-    new(message: string, innerException: Exception): SynchronizationLockException$instance;
+    new(): SynchronizationLockException;
+    new(message: string | undefined): SynchronizationLockException;
+    new(message: string | undefined, innerException: Exception | undefined): SynchronizationLockException;
 };
 
 
@@ -1002,7 +1002,7 @@ export interface Thread$instance extends CriticalFinalizerObject {
     apartmentState: ApartmentState;
     currentCulture: CultureInfo;
     currentUICulture: CultureInfo;
-    readonly executionContext: ExecutionContext;
+    readonly executionContext: ExecutionContext | undefined;
     readonly isAlive: boolean;
     isBackground: boolean;
     readonly isThreadPoolThread: boolean;
@@ -1033,11 +1033,11 @@ export interface Thread$instance extends CriticalFinalizerObject {
 
 
 export const Thread: {
-    new(start: ThreadStart): Thread$instance;
-    new(start: ThreadStart, maxStackSize: int): Thread$instance;
-    new(start: ParameterizedThreadStart): Thread$instance;
-    new(start: ParameterizedThreadStart, maxStackSize: int): Thread$instance;
-    currentPrincipal: IPrincipal;
+    new(start: ThreadStart): Thread;
+    new(start: ThreadStart, maxStackSize: int): Thread;
+    new(start: ParameterizedThreadStart): Thread;
+    new(start: ParameterizedThreadStart, maxStackSize: int): Thread;
+    currentPrincipal: IPrincipal | undefined;
     readonly currentThread: Thread;
     allocateDataSlot(): LocalDataStoreSlot;
     allocateNamedDataSlot(name: string): LocalDataStoreSlot;
@@ -1047,13 +1047,13 @@ export const Thread: {
     endThreadAffinity(): void;
     freeNamedDataSlot(name: string): void;
     getCurrentProcessorId(): int;
-    getData(slot: LocalDataStoreSlot): unknown;
+    getData(slot: LocalDataStoreSlot): unknown | undefined;
     getDomain(): AppDomain;
     getDomainID(): int;
     getNamedDataSlot(name: string): LocalDataStoreSlot;
     memoryBarrier(): void;
     resetAbort(): void;
-    setData(slot: LocalDataStoreSlot, data: unknown): void;
+    setData(slot: LocalDataStoreSlot, data: unknown | undefined): void;
     sleep(millisecondsTimeout: int): void;
     sleep(timeout: TimeSpan): void;
     spinWait(iterations: int): void;
@@ -1090,13 +1090,13 @@ export const Thread: {
 export type Thread = Thread$instance;
 
 export interface ThreadAbortException$instance extends SystemException {
-    readonly exceptionState: unknown;
+    readonly exceptionState: unknown | undefined;
     getObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
 
 export const ThreadAbortException: {
-    new(): ThreadAbortException$instance;
+    new(): ThreadAbortException;
 };
 
 
@@ -1113,7 +1113,7 @@ export interface ThreadExceptionEventArgs$instance extends EventArgs {
 
 
 export const ThreadExceptionEventArgs: {
-    new(t: Exception): ThreadExceptionEventArgs$instance;
+    new(t: Exception): ThreadExceptionEventArgs;
 };
 
 
@@ -1125,9 +1125,9 @@ export interface ThreadInterruptedException$instance extends SystemException {
 
 
 export const ThreadInterruptedException: {
-    new(): ThreadInterruptedException$instance;
-    new(message: string): ThreadInterruptedException$instance;
-    new(message: string, innerException: Exception): ThreadInterruptedException$instance;
+    new(): ThreadInterruptedException;
+    new(message: string | undefined): ThreadInterruptedException;
+    new(message: string | undefined, innerException: Exception | undefined): ThreadInterruptedException;
 };
 
 
@@ -1148,10 +1148,10 @@ export interface ThreadLocal_1$instance<T> {
 
 
 export const ThreadLocal_1: {
-    new<T>(): ThreadLocal_1$instance<T>;
-    new<T>(trackAllValues: boolean): ThreadLocal_1$instance<T>;
-    new<T>(valueFactory: Func_1<T>): ThreadLocal_1$instance<T>;
-    new<T>(valueFactory: Func_1<T>, trackAllValues: boolean): ThreadLocal_1$instance<T>;
+    new<T>(): ThreadLocal_1<T>;
+    new<T>(trackAllValues: boolean): ThreadLocal_1<T>;
+    new<T>(valueFactory: Func_1<T>): ThreadLocal_1<T>;
+    new<T>(valueFactory: Func_1<T>, trackAllValues: boolean): ThreadLocal_1<T>;
 };
 
 
@@ -1175,9 +1175,9 @@ export interface ThreadPoolBoundHandle$instance {
 
 
 export const ThreadPoolBoundHandle: {
-    new(): ThreadPoolBoundHandle$instance;
+    new(): ThreadPoolBoundHandle;
     bindHandle(handle: SafeHandle): ThreadPoolBoundHandle;
-    getNativeOverlappedState(overlapped: ptr<NativeOverlapped>): unknown;
+    getNativeOverlappedState(overlapped: ptr<NativeOverlapped>): unknown | undefined;
 };
 
 
@@ -1196,7 +1196,7 @@ export interface ThreadStartException$instance extends SystemException {
 
 
 export const ThreadStartException: {
-    new(): ThreadStartException$instance;
+    new(): ThreadStartException;
 };
 
 
@@ -1213,9 +1213,9 @@ export interface ThreadStateException$instance extends SystemException {
 
 
 export const ThreadStateException: {
-    new(): ThreadStateException$instance;
-    new(message: string): ThreadStateException$instance;
-    new(message: string, innerException: Exception): ThreadStateException$instance;
+    new(): ThreadStateException;
+    new(message: string | undefined): ThreadStateException;
+    new(message: string | undefined, innerException: Exception | undefined): ThreadStateException;
 };
 
 
@@ -1238,11 +1238,11 @@ export interface Timer$instance extends MarshalByRefObject {
 
 
 export const Timer: {
-    new(callback: TimerCallback, state: unknown, dueTime: int, period: int): Timer$instance;
-    new(callback: TimerCallback, state: unknown, dueTime: TimeSpan, period: TimeSpan): Timer$instance;
-    new(callback: TimerCallback, state: unknown, dueTime: uint, period: uint): Timer$instance;
-    new(callback: TimerCallback, state: unknown, dueTime: long, period: long): Timer$instance;
-    new(callback: TimerCallback): Timer$instance;
+    new(callback: TimerCallback, state: unknown | undefined, dueTime: int, period: int): Timer;
+    new(callback: TimerCallback, state: unknown | undefined, dueTime: TimeSpan, period: TimeSpan): Timer;
+    new(callback: TimerCallback, state: unknown | undefined, dueTime: uint, period: uint): Timer;
+    new(callback: TimerCallback, state: unknown | undefined, dueTime: long, period: long): Timer;
+    new(callback: TimerCallback): Timer;
     readonly activeCount: long;
 };
 
@@ -1302,9 +1302,9 @@ export interface WaitHandleCannotBeOpenedException$instance extends ApplicationE
 
 
 export const WaitHandleCannotBeOpenedException: {
-    new(): WaitHandleCannotBeOpenedException$instance;
-    new(message: string): WaitHandleCannotBeOpenedException$instance;
-    new(message: string, innerException: Exception): WaitHandleCannotBeOpenedException$instance;
+    new(): WaitHandleCannotBeOpenedException;
+    new(message: string | undefined): WaitHandleCannotBeOpenedException;
+    new(message: string | undefined, innerException: Exception | undefined): WaitHandleCannotBeOpenedException;
 };
 
 
@@ -1318,7 +1318,7 @@ export type WaitHandleCannotBeOpenedException = WaitHandleCannotBeOpenedExceptio
 export abstract class EventWaitHandleAcl$instance {
     static create(initialState: boolean, mode: EventResetMode, name: string, createdNew: boolean, eventSecurity: EventWaitHandleSecurity): EventWaitHandle;
     static openExisting(name: string, rights: EventWaitHandleRights): EventWaitHandle;
-    static tryOpenExisting(name: string, rights: EventWaitHandleRights, result: EventWaitHandle): boolean;
+    static tryOpenExisting(name: string, rights: EventWaitHandleRights, result: EventWaitHandle | undefined): boolean;
 }
 
 
@@ -1383,11 +1383,11 @@ export abstract class Interlocked$instance {
 export type Interlocked = Interlocked$instance;
 
 export abstract class LazyInitializer$instance {
-    static ensureInitialized<T>(target: T, valueFactory: Func_1<T>): T;
-    static ensureInitialized<T>(target: T, initialized: boolean, syncLock: unknown, valueFactory: Func_1<T>): T;
-    static ensureInitialized<T>(target: T, initialized: boolean, syncLock: unknown): T;
-    static ensureInitialized<T>(target: T, syncLock: unknown, valueFactory: Func_1<T>): T;
-    static ensureInitialized<T>(target: T): T;
+    static ensureInitialized<T>(target: T | undefined, valueFactory: Func_1<T>): T;
+    static ensureInitialized<T>(target: T, initialized: boolean, syncLock: unknown | undefined, valueFactory: Func_1<T>): T;
+    static ensureInitialized<T>(target: T, initialized: boolean, syncLock: unknown | undefined): T;
+    static ensureInitialized<T>(target: T | undefined, syncLock: unknown | undefined, valueFactory: Func_1<T>): T;
+    static ensureInitialized<T>(target: T | undefined): T;
 }
 
 
@@ -1420,7 +1420,7 @@ export type Monitor = Monitor$instance;
 export abstract class MutexAcl$instance {
     static create(initiallyOwned: boolean, name: string, createdNew: boolean, mutexSecurity: MutexSecurity): Mutex;
     static openExisting(name: string, rights: MutexRights): Mutex;
-    static tryOpenExisting(name: string, rights: MutexRights, result: Mutex): boolean;
+    static tryOpenExisting(name: string, rights: MutexRights, result: Mutex | undefined): boolean;
 }
 
 
@@ -1429,7 +1429,7 @@ export type MutexAcl = MutexAcl$instance;
 export abstract class SemaphoreAcl$instance {
     static create(initialCount: int, maximumCount: int, name: string, createdNew: boolean, semaphoreSecurity: SemaphoreSecurity): Semaphore;
     static openExisting(name: string, rights: SemaphoreRights): Semaphore;
-    static tryOpenExisting(name: string, rights: SemaphoreRights, result: Semaphore): boolean;
+    static tryOpenExisting(name: string, rights: SemaphoreRights, result: Semaphore | undefined): boolean;
 }
 
 
@@ -1457,22 +1457,22 @@ export abstract class ThreadPool$instance {
     static getMaxThreads(workerThreads: int, completionPortThreads: int): void;
     static getMinThreads(workerThreads: int, completionPortThreads: int): void;
     static queueUserWorkItem<TState>(callBack: Action_1<TState>, state: TState, preferLocal: boolean): boolean;
-    static queueUserWorkItem(callBack: WaitCallback, state: unknown): boolean;
+    static queueUserWorkItem(callBack: WaitCallback, state: unknown | undefined): boolean;
     static queueUserWorkItem(callBack: WaitCallback): boolean;
-    static registerWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown, millisecondsTimeOutInterval: int, executeOnlyOnce: boolean): RegisteredWaitHandle;
-    static registerWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown, millisecondsTimeOutInterval: long, executeOnlyOnce: boolean): RegisteredWaitHandle;
-    static registerWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown, timeout: TimeSpan, executeOnlyOnce: boolean): RegisteredWaitHandle;
-    static registerWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown, millisecondsTimeOutInterval: uint, executeOnlyOnce: boolean): RegisteredWaitHandle;
+    static registerWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown | undefined, millisecondsTimeOutInterval: int, executeOnlyOnce: boolean): RegisteredWaitHandle;
+    static registerWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown | undefined, millisecondsTimeOutInterval: long, executeOnlyOnce: boolean): RegisteredWaitHandle;
+    static registerWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown | undefined, timeout: TimeSpan, executeOnlyOnce: boolean): RegisteredWaitHandle;
+    static registerWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown | undefined, millisecondsTimeOutInterval: uint, executeOnlyOnce: boolean): RegisteredWaitHandle;
     static setMaxThreads(workerThreads: int, completionPortThreads: int): boolean;
     static setMinThreads(workerThreads: int, completionPortThreads: int): boolean;
     static unsafeQueueNativeOverlapped(overlapped: ptr<NativeOverlapped>): boolean;
     static unsafeQueueUserWorkItem<TState>(callBack: Action_1<TState>, state: TState, preferLocal: boolean): boolean;
     static unsafeQueueUserWorkItem(callBack: IThreadPoolWorkItem, preferLocal: boolean): boolean;
-    static unsafeQueueUserWorkItem(callBack: WaitCallback, state: unknown): boolean;
-    static unsafeRegisterWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown, millisecondsTimeOutInterval: int, executeOnlyOnce: boolean): RegisteredWaitHandle;
-    static unsafeRegisterWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown, millisecondsTimeOutInterval: long, executeOnlyOnce: boolean): RegisteredWaitHandle;
-    static unsafeRegisterWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown, timeout: TimeSpan, executeOnlyOnce: boolean): RegisteredWaitHandle;
-    static unsafeRegisterWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown, millisecondsTimeOutInterval: uint, executeOnlyOnce: boolean): RegisteredWaitHandle;
+    static unsafeQueueUserWorkItem(callBack: WaitCallback, state: unknown | undefined): boolean;
+    static unsafeRegisterWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown | undefined, millisecondsTimeOutInterval: int, executeOnlyOnce: boolean): RegisteredWaitHandle;
+    static unsafeRegisterWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown | undefined, millisecondsTimeOutInterval: long, executeOnlyOnce: boolean): RegisteredWaitHandle;
+    static unsafeRegisterWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown | undefined, timeout: TimeSpan, executeOnlyOnce: boolean): RegisteredWaitHandle;
+    static unsafeRegisterWaitForSingleObject(waitObject: WaitHandle, callBack: WaitOrTimerCallback, state: unknown | undefined, millisecondsTimeOutInterval: uint, executeOnlyOnce: boolean): RegisteredWaitHandle;
 }
 
 
@@ -1524,7 +1524,7 @@ export type Volatile = Volatile$instance;
 
 export abstract class WaitHandleExtensions$instance {
     static getSafeWaitHandle(waitHandle: WaitHandle): SafeWaitHandle;
-    static setSafeWaitHandle(waitHandle: WaitHandle, value: SafeWaitHandle): void;
+    static setSafeWaitHandle(waitHandle: WaitHandle, value: SafeWaitHandle | undefined): void;
 }