@tsonic/dotnet 10.0.4 → 10.0.9

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

@@ -102,6 +102,8 @@ export type WaitOrTimerCallback = (state: unknown, timedOut: boolean) => void;
 
 
 export interface IThreadPoolWorkItem$instance {
+    readonly __tsonic_iface_System_Threading_IThreadPoolWorkItem: never;
+
     Execute(): void;
 }
 
@@ -109,6 +111,8 @@ export interface IThreadPoolWorkItem$instance {
 export type IThreadPoolWorkItem = IThreadPoolWorkItem$instance;
 
 export interface ITimer$instance extends IDisposable, IAsyncDisposable {
+    readonly __tsonic_iface_System_Threading_ITimer: never;
+
     Change(dueTime: TimeSpan, period: TimeSpan): boolean;
     Dispose(): void;
     DisposeAsync(): ValueTask;
@@ -119,7 +123,12 @@ export interface ITimer$instance extends System_Internal.IAsyncDisposable$instan
 
 export type ITimer = ITimer$instance;
 
-export interface AsyncFlowControl$instance {
+export interface AsyncFlowControl$instance extends System_Internal.IDisposable$instance {
+    readonly __tsonic_type_System_Threading_AsyncFlowControl: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     Dispose(): void;
     Equals(obj: unknown): boolean;
     Equals(obj: AsyncFlowControl): boolean;
@@ -141,12 +150,12 @@ export interface __AsyncFlowControl$views {
     Equals(other: AsyncFlowControl): boolean;
 }
 
-export interface AsyncFlowControl$instance extends System_Internal.IDisposable$instance {}
-
 export type AsyncFlowControl = AsyncFlowControl$instance & __AsyncFlowControl$views;
 
 
 export interface AsyncLocalValueChangedArgs_1$instance<T> {
+    readonly __tsonic_type_System_Threading_AsyncLocalValueChangedArgs_1: never;
+
     readonly CurrentValue: T | undefined;
     readonly PreviousValue: T | undefined;
     readonly ThreadContextChanged: boolean;
@@ -161,6 +170,10 @@ export const AsyncLocalValueChangedArgs_1: {
 export type AsyncLocalValueChangedArgs_1<T> = AsyncLocalValueChangedArgs_1$instance<T>;
 
 export interface CancellationToken$instance {
+    readonly __tsonic_type_System_Threading_CancellationToken: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly CanBeCanceled: boolean;
     readonly IsCancellationRequested: boolean;
     readonly WaitHandle: WaitHandle;
@@ -194,7 +207,13 @@ export interface __CancellationToken$views {
 export type CancellationToken = CancellationToken$instance & __CancellationToken$views;
 
 
-export interface CancellationTokenRegistration$instance {
+export interface CancellationTokenRegistration$instance extends System_Internal.IAsyncDisposable$instance, System_Internal.IDisposable$instance {
+    readonly __tsonic_type_System_Threading_CancellationTokenRegistration: never;
+
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly Token: CancellationToken;
     Dispose(): void;
     DisposeAsync(): ValueTask;
@@ -219,12 +238,12 @@ export interface __CancellationTokenRegistration$views {
     Equals(other: CancellationTokenRegistration): boolean;
 }
 
-export interface CancellationTokenRegistration$instance extends System_Internal.IAsyncDisposable$instance, System_Internal.IDisposable$instance {}
-
 export type CancellationTokenRegistration = CancellationTokenRegistration$instance & __CancellationTokenRegistration$views;
 
 
 export interface Lock_Scope$instance {
+    readonly __tsonic_type_System_Threading_Lock_Scope: never;
+
     Dispose(): void;
 }
 
@@ -237,6 +256,10 @@ export const Lock_Scope: {
 export type Lock_Scope = Lock_Scope$instance;
 
 export interface LockCookie$instance {
+    readonly __tsonic_type_System_Threading_LockCookie: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     Equals(obj: unknown): boolean;
     Equals(obj: LockCookie): boolean;
     GetHashCode(): int;
@@ -259,6 +282,8 @@ export type LockCookie = LockCookie$instance & __LockCookie$views;
 
 
 export interface NamedWaitHandleOptions$instance {
+    readonly __tsonic_type_System_Threading_NamedWaitHandleOptions: never;
+
     CurrentSessionOnly: boolean;
     CurrentUserOnly: boolean;
 }
@@ -272,6 +297,8 @@ export const NamedWaitHandleOptions: {
 export type NamedWaitHandleOptions = NamedWaitHandleOptions$instance;
 
 export interface NativeOverlapped$instance {
+    readonly __tsonic_type_System_Threading_NativeOverlapped: never;
+
     InternalLow: nint;
     InternalHigh: nint;
     OffsetLow: int;
@@ -288,6 +315,8 @@ export const NativeOverlapped: {
 export type NativeOverlapped = NativeOverlapped$instance;
 
 export interface SpinLock$instance {
+    readonly __tsonic_type_System_Threading_SpinLock: never;
+
     readonly IsHeld: boolean;
     readonly IsHeldByCurrentThread: boolean;
     readonly IsThreadOwnerTrackingEnabled: boolean;
@@ -308,6 +337,8 @@ export const SpinLock: {
 export type SpinLock = SpinLock$instance;
 
 export interface SpinWait$instance {
+    readonly __tsonic_type_System_Threading_SpinWait: never;
+
     Count: int;
     readonly NextSpinWillYield: boolean;
     Reset(): void;
@@ -327,6 +358,10 @@ export const SpinWait: {
 export type SpinWait = SpinWait$instance;
 
 export interface AbandonedMutexException$instance extends SystemException {
+    readonly __tsonic_type_System_Threading_AbandonedMutexException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     readonly Mutex: Mutex | undefined;
     readonly MutexIndex: int;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
@@ -351,6 +386,10 @@ export type AbandonedMutexException = AbandonedMutexException$instance & __Aband
 
 
 export interface AsyncLocal_1$instance<T> {
+    readonly __tsonic_type_System_Threading_AsyncLocal_1: never;
+
+    readonly __tsonic_iface_System_Threading_IAsyncLocal: never;
+
     Value: T;
 }
 
@@ -364,6 +403,10 @@ export const AsyncLocal_1: {
 export type AsyncLocal_1<T> = AsyncLocal_1$instance<T>;
 
 export interface AutoResetEvent$instance extends EventWaitHandle$instance {
+    readonly __tsonic_type_System_Threading_AutoResetEvent: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(): void;
     Dispose(explicitDisposing: boolean): void;
 }
@@ -382,6 +425,10 @@ export type AutoResetEvent = AutoResetEvent$instance & __AutoResetEvent$views;
 
 
 export interface Barrier$instance {
+    readonly __tsonic_type_System_Threading_Barrier: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     CurrentPhaseNumber: long;
     readonly ParticipantCount: int;
     readonly ParticipantsRemaining: int;
@@ -414,6 +461,10 @@ export type Barrier = Barrier$instance & __Barrier$views;
 
 
 export interface BarrierPostPhaseException$instance extends Exception {
+    readonly __tsonic_type_System_Threading_BarrierPostPhaseException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -434,6 +485,10 @@ export type BarrierPostPhaseException = BarrierPostPhaseException$instance & __B
 
 
 export interface CancellationTokenSource$instance {
+    readonly __tsonic_type_System_Threading_CancellationTokenSource: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly IsCancellationRequested: boolean;
     readonly Token: CancellationToken;
     Cancel(): void;
@@ -466,7 +521,11 @@ export interface __CancellationTokenSource$views {
 export type CancellationTokenSource = CancellationTokenSource$instance & __CancellationTokenSource$views;
 
 
-export interface CompressedStack$instance {
+export interface CompressedStack$instance extends System_Runtime_Serialization_Internal.ISerializable$instance {
+    readonly __tsonic_type_System_Threading_CompressedStack: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     CreateCopy(): CompressedStack;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -483,12 +542,14 @@ export interface __CompressedStack$views {
     As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
 }
 
-export interface CompressedStack$instance extends System_Runtime_Serialization_Internal.ISerializable$instance {}
-
 export type CompressedStack = CompressedStack$instance & __CompressedStack$views;
 
 
 export interface CountdownEvent$instance {
+    readonly __tsonic_type_System_Threading_CountdownEvent: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly CurrentCount: int;
     readonly InitialCount: int;
     readonly IsSet: boolean;
@@ -525,6 +586,10 @@ export type CountdownEvent = CountdownEvent$instance & __CountdownEvent$views;
 
 
 export interface EventWaitHandle$instance extends WaitHandle$instance {
+    readonly __tsonic_type_System_Threading_EventWaitHandle: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(explicitDisposing: boolean): void;
     Dispose(): void;
     Reset(): boolean;
@@ -552,7 +617,12 @@ export interface __EventWaitHandle$views {
 export type EventWaitHandle = EventWaitHandle$instance & __EventWaitHandle$views;
 
 
-export interface ExecutionContext$instance {
+export interface ExecutionContext$instance extends System_Internal.IDisposable$instance, System_Runtime_Serialization_Internal.ISerializable$instance {
+    readonly __tsonic_type_System_Threading_ExecutionContext: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     CreateCopy(): ExecutionContext;
     Dispose(): void;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
@@ -574,12 +644,14 @@ export interface __ExecutionContext$views {
     As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
 }
 
-export interface ExecutionContext$instance extends System_Internal.IDisposable$instance, System_Runtime_Serialization_Internal.ISerializable$instance {}
-
 export type ExecutionContext = ExecutionContext$instance & __ExecutionContext$views;
 
 
 export interface HostExecutionContext$instance {
+    readonly __tsonic_type_System_Threading_HostExecutionContext: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     CreateCopy(): HostExecutionContext;
     Dispose(): void;
     Dispose(disposing: boolean): void;
@@ -600,6 +672,8 @@ export type HostExecutionContext = HostExecutionContext$instance & __HostExecuti
 
 
 export interface HostExecutionContextManager$instance {
+    readonly __tsonic_type_System_Threading_HostExecutionContextManager: never;
+
     Capture(): HostExecutionContext | undefined;
     Revert(previousState: unknown): void;
     SetHostExecutionContext(hostExecutionContext: HostExecutionContext): unknown;
@@ -614,6 +688,8 @@ export const HostExecutionContextManager: {
 export type HostExecutionContextManager = HostExecutionContextManager$instance;
 
 export interface Lock$instance {
+    readonly __tsonic_type_System_Threading_Lock: never;
+
     readonly IsHeldByCurrentThread: boolean;
     Enter(): void;
     EnterScope(): Lock_Scope;
@@ -632,6 +708,10 @@ export const Lock: {
 export type Lock = Lock$instance;
 
 export interface LockRecursionException$instance extends Exception {
+    readonly __tsonic_type_System_Threading_LockRecursionException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -651,6 +731,10 @@ export type LockRecursionException = LockRecursionException$instance & __LockRec
 
 
 export interface ManualResetEvent$instance extends EventWaitHandle$instance {
+    readonly __tsonic_type_System_Threading_ManualResetEvent: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(): void;
     Dispose(explicitDisposing: boolean): void;
 }
@@ -669,6 +753,10 @@ export type ManualResetEvent = ManualResetEvent$instance & __ManualResetEvent$vi
 
 
 export interface ManualResetEventSlim$instance {
+    readonly __tsonic_type_System_Threading_ManualResetEventSlim: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     IsSet: boolean;
     SpinCount: int;
     readonly WaitHandle: WaitHandle;
@@ -700,6 +788,10 @@ export type ManualResetEventSlim = ManualResetEventSlim$instance & __ManualReset
 
 
 export interface Mutex$instance extends WaitHandle$instance {
+    readonly __tsonic_type_System_Threading_Mutex: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(explicitDisposing: boolean): void;
     Dispose(): void;
     ReleaseMutex(): void;
@@ -729,6 +821,8 @@ export type Mutex = Mutex$instance & __Mutex$views;
 
 
 export interface Overlapped$instance {
+    readonly __tsonic_type_System_Threading_Overlapped: never;
+
     AsyncResult: IAsyncResult;
     EventHandle: int;
     EventHandleIntPtr: nint;
@@ -752,7 +846,11 @@ export const Overlapped: {
 
 export type Overlapped = Overlapped$instance;
 
-export interface PeriodicTimer$instance {
+export interface PeriodicTimer$instance extends System_Internal.IDisposable$instance {
+    readonly __tsonic_type_System_Threading_PeriodicTimer: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Period: TimeSpan;
     Dispose(): void;
     Finalize(): void;
@@ -770,12 +868,14 @@ export interface __PeriodicTimer$views {
     As_IDisposable(): System_Internal.IDisposable$instance;
 }
 
-export interface PeriodicTimer$instance extends System_Internal.IDisposable$instance {}
-
 export type PeriodicTimer = PeriodicTimer$instance & __PeriodicTimer$views;
 
 
-export interface PreAllocatedOverlapped$instance {
+export interface PreAllocatedOverlapped$instance extends System_Internal.IDisposable$instance {
+    readonly __tsonic_type_System_Threading_PreAllocatedOverlapped: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(): void;
 }
 
@@ -790,12 +890,12 @@ export interface __PreAllocatedOverlapped$views {
     As_IDisposable(): System_Internal.IDisposable$instance;
 }
 
-export interface PreAllocatedOverlapped$instance extends System_Internal.IDisposable$instance {}
-
 export type PreAllocatedOverlapped = PreAllocatedOverlapped$instance & __PreAllocatedOverlapped$views;
 
 
 export interface ReaderWriterLock$instance extends CriticalFinalizerObject {
+    readonly __tsonic_type_System_Threading_ReaderWriterLock: never;
+
     readonly IsReaderLockHeld: boolean;
     readonly IsWriterLockHeld: boolean;
     readonly WriterSeqNum: int;
@@ -821,7 +921,11 @@ export const ReaderWriterLock: {
 
 export type ReaderWriterLock = ReaderWriterLock$instance;
 
-export interface ReaderWriterLockSlim$instance {
+export interface ReaderWriterLockSlim$instance extends System_Internal.IDisposable$instance {
+    readonly __tsonic_type_System_Threading_ReaderWriterLockSlim: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly CurrentReadCount: int;
     readonly IsReadLockHeld: boolean;
     readonly IsUpgradeableReadLockHeld: boolean;
@@ -859,12 +963,12 @@ export interface __ReaderWriterLockSlim$views {
     As_IDisposable(): System_Internal.IDisposable$instance;
 }
 
-export interface ReaderWriterLockSlim$instance extends System_Internal.IDisposable$instance {}
-
 export type ReaderWriterLockSlim = ReaderWriterLockSlim$instance & __ReaderWriterLockSlim$views;
 
 
 export interface RegisteredWaitHandle$instance extends MarshalByRefObject {
+    readonly __tsonic_type_System_Threading_RegisteredWaitHandle: never;
+
     Unregister(waitObject: WaitHandle): boolean;
 }
 
@@ -876,6 +980,10 @@ export const RegisteredWaitHandle: {
 export type RegisteredWaitHandle = RegisteredWaitHandle$instance;
 
 export interface Semaphore$instance extends WaitHandle$instance {
+    readonly __tsonic_type_System_Threading_Semaphore: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(explicitDisposing: boolean): void;
     Dispose(): void;
     Release(): int;
@@ -904,6 +1012,10 @@ export type Semaphore = Semaphore$instance & __Semaphore$views;
 
 
 export interface SemaphoreFullException$instance extends SystemException {
+    readonly __tsonic_type_System_Threading_SemaphoreFullException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -923,6 +1035,10 @@ export type SemaphoreFullException = SemaphoreFullException$instance & __Semapho
 
 
 export interface SemaphoreSlim$instance {
+    readonly __tsonic_type_System_Threading_SemaphoreSlim: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly AvailableWaitHandle: WaitHandle;
     readonly CurrentCount: int;
     Dispose(): void;
@@ -958,6 +1074,8 @@ export type SemaphoreSlim = SemaphoreSlim$instance & __SemaphoreSlim$views;
 
 
 export interface SynchronizationContext$instance {
+    readonly __tsonic_type_System_Threading_SynchronizationContext: never;
+
     CreateCopy(): SynchronizationContext;
     IsWaitNotificationRequired(): boolean;
     OperationCompleted(): void;
@@ -979,6 +1097,10 @@ export const SynchronizationContext: {
 export type SynchronizationContext = SynchronizationContext$instance;
 
 export interface SynchronizationLockException$instance extends SystemException {
+    readonly __tsonic_type_System_Threading_SynchronizationLockException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -998,6 +1120,8 @@ export type SynchronizationLockException = SynchronizationLockException$instance
 
 
 export interface Thread$instance extends CriticalFinalizerObject {
+    readonly __tsonic_type_System_Threading_Thread: never;
+
     ApartmentState: ApartmentState;
     CurrentCulture: CultureInfo;
     CurrentUICulture: CultureInfo;
@@ -1092,6 +1216,10 @@ export const Thread: {
 export type Thread = Thread$instance;
 
 export interface ThreadAbortException$instance extends SystemException {
+    readonly __tsonic_type_System_Threading_ThreadAbortException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     readonly ExceptionState: unknown | undefined;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -1109,6 +1237,8 @@ export type ThreadAbortException = ThreadAbortException$instance & __ThreadAbort
 
 
 export interface ThreadExceptionEventArgs$instance extends EventArgs {
+    readonly __tsonic_type_System_Threading_ThreadExceptionEventArgs: never;
+
     readonly Exception: Exception;
 }
 
@@ -1121,6 +1251,10 @@ export const ThreadExceptionEventArgs: {
 export type ThreadExceptionEventArgs = ThreadExceptionEventArgs$instance;
 
 export interface ThreadInterruptedException$instance extends SystemException {
+    readonly __tsonic_type_System_Threading_ThreadInterruptedException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -1140,6 +1274,10 @@ export type ThreadInterruptedException = ThreadInterruptedException$instance & _
 
 
 export interface ThreadLocal_1$instance<T> {
+    readonly __tsonic_type_System_Threading_ThreadLocal_1: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly IsValueCreated: boolean;
     Value: T;
     readonly Values: IList_1<T>;
@@ -1165,7 +1303,11 @@ export interface __ThreadLocal_1$views<T> {
 export type ThreadLocal_1<T> = ThreadLocal_1$instance<T> & __ThreadLocal_1$views<T>;
 
 
-export interface ThreadPoolBoundHandle$instance {
+export interface ThreadPoolBoundHandle$instance extends System_Internal.IDisposable$instance {
+    readonly __tsonic_type_System_Threading_ThreadPoolBoundHandle: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly Handle: SafeHandle;
     AllocateNativeOverlapped(callback: IOCompletionCallback, state: unknown, pinData: unknown): ptr<NativeOverlapped>;
     AllocateNativeOverlapped(preAllocated: PreAllocatedOverlapped): ptr<NativeOverlapped>;
@@ -1185,12 +1327,14 @@ export interface __ThreadPoolBoundHandle$views {
     As_IDisposable(): System_Internal.IDisposable$instance;
 }
 
-export interface ThreadPoolBoundHandle$instance extends System_Internal.IDisposable$instance {}
-
 export type ThreadPoolBoundHandle = ThreadPoolBoundHandle$instance & __ThreadPoolBoundHandle$views;
 
 
 export interface ThreadStartException$instance extends SystemException {
+    readonly __tsonic_type_System_Threading_ThreadStartException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -1207,6 +1351,10 @@ export type ThreadStartException = ThreadStartException$instance & __ThreadStart
 
 
 export interface ThreadStateException$instance extends SystemException {
+    readonly __tsonic_type_System_Threading_ThreadStateException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -1226,6 +1374,12 @@ export type ThreadStateException = ThreadStateException$instance & __ThreadState
 
 
 export interface Timer$instance extends MarshalByRefObject {
+    readonly __tsonic_type_System_Threading_Timer: never;
+
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+    readonly __tsonic_iface_System_Threading_ITimer: never;
+
     Change(dueTime: int, period: int): boolean;
     Change(dueTime: TimeSpan, period: TimeSpan): boolean;
     Change(dueTime: uint, period: uint): boolean;
@@ -1256,6 +1410,10 @@ export type Timer = Timer$instance & __Timer$views;
 
 
 export interface WaitHandle$instance extends MarshalByRefObject {
+    readonly __tsonic_type_System_Threading_WaitHandle: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Handle: nint;
     SafeWaitHandle: SafeWaitHandle;
     Close(): void;
@@ -1296,6 +1454,10 @@ export type WaitHandle = WaitHandle$instance & __WaitHandle$views;
 
 
 export interface WaitHandleCannotBeOpenedException$instance extends ApplicationException {
+    readonly __tsonic_type_System_Threading_WaitHandleCannotBeOpenedException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 

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

@@ -28,6 +28,8 @@ export enum BoundedChannelFullMode {
 
 
 export interface BoundedChannelOptions$instance extends ChannelOptions {
+    readonly __tsonic_type_System_Threading_Channels_BoundedChannelOptions: never;
+
     Capacity: int;
     FullMode: BoundedChannelFullMode;
 }
@@ -41,6 +43,8 @@ export const BoundedChannelOptions: {
 export type BoundedChannelOptions = BoundedChannelOptions$instance;
 
 export interface Channel_1$instance<T> extends Channel_2<T, T> {
+    readonly __tsonic_type_System_Threading_Channels_Channel_1: never;
+
 }
 
 
@@ -51,6 +55,8 @@ export const Channel_1: (abstract new<T>() => Channel_1<T>) & {
 export type Channel_1<T> = Channel_1$instance<T>;
 
 export interface Channel_2$instance<TWrite, TRead> {
+    readonly __tsonic_type_System_Threading_Channels_Channel_2: never;
+
     Reader: ChannelReader_1<TRead>;
     Writer: ChannelWriter_1<TWrite>;
 }
@@ -63,6 +69,10 @@ export const Channel_2: (abstract new<TWrite, TRead>() => Channel_2<TWrite, TRea
 export type Channel_2<TWrite, TRead> = Channel_2$instance<TWrite, TRead>;
 
 export interface ChannelClosedException$instance extends InvalidOperationException {
+    readonly __tsonic_type_System_Threading_Channels_ChannelClosedException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -83,6 +93,8 @@ export type ChannelClosedException = ChannelClosedException$instance & __Channel
 
 
 export interface ChannelOptions$instance {
+    readonly __tsonic_type_System_Threading_Channels_ChannelOptions: never;
+
     AllowSynchronousContinuations: boolean;
     SingleReader: boolean;
     SingleWriter: boolean;
@@ -96,6 +108,8 @@ export const ChannelOptions: (abstract new() => ChannelOptions) & {
 export type ChannelOptions = ChannelOptions$instance;
 
 export interface ChannelReader_1$instance<T> {
+    readonly __tsonic_type_System_Threading_Channels_ChannelReader_1: never;
+
     readonly CanCount: boolean;
     readonly CanPeek: boolean;
     readonly Completion: Task;
@@ -115,6 +129,8 @@ export const ChannelReader_1: (abstract new<T>() => ChannelReader_1<T>) & {
 export type ChannelReader_1<T> = ChannelReader_1$instance<T>;
 
 export interface ChannelWriter_1$instance<T> {
+    readonly __tsonic_type_System_Threading_Channels_ChannelWriter_1: never;
+
     Complete(error?: Exception): void;
     TryComplete(error?: Exception): boolean;
     TryWrite(item: T): boolean;
@@ -130,6 +146,8 @@ export const ChannelWriter_1: (abstract new<T>() => ChannelWriter_1<T>) & {
 export type ChannelWriter_1<T> = ChannelWriter_1$instance<T>;
 
 export interface UnboundedChannelOptions$instance extends ChannelOptions {
+    readonly __tsonic_type_System_Threading_Channels_UnboundedChannelOptions: never;
+
 }
 
 
@@ -141,6 +159,8 @@ export const UnboundedChannelOptions: {
 export type UnboundedChannelOptions = UnboundedChannelOptions$instance;
 
 export interface UnboundedPrioritizedChannelOptions_1$instance<T> extends ChannelOptions {
+    readonly __tsonic_type_System_Threading_Channels_UnboundedPrioritizedChannelOptions_1: never;
+
     get Comparer(): IComparer_1<T> | undefined;
     set Comparer(value: IComparer_1<T> | undefined);
 }