@tsonic/efcore-sqlserver 10.0.2 → 10.0.7

package/Microsoft.Data.SqlClient/internal/index.d.ts

@@ -13,27 +13,27 @@ import type { SqlNotificationRequest } from "../../Microsoft.Data.Sql/internal/i
 import type { SensitivityClassification } from "../../Microsoft.Data.SqlClient.DataClassification/internal/index.js";
 import type { SqlJson, SqlVector_1 } from "../../Microsoft.Data.SqlTypes/internal/index.js";
 import type { DeviceCodeResult } from "../../Microsoft.Identity.Client/internal/index.js";
-import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { ICollection as ICollection__System_Collections_Generic, IDictionary as IDictionary__System_Collections_Generic, IEnumerable as IEnumerable__System_Collections_Generic, IEnumerator as IEnumerator__System_Collections_Generic, IList as IList__System_Collections_Generic, List } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Collections_Internal from "@tsonic/dotnet/System.Collections.js";
-import type { CollectionBase, ICollection, IDictionary, IEnumerable, IEnumerator, IList } from "@tsonic/dotnet/System.Collections.js";
-import type { ReadOnlyCollection } from "@tsonic/dotnet/System.Collections.ObjectModel.js";
-import * as System_ComponentModel_Internal from "@tsonic/dotnet/System.ComponentModel.js";
-import type { IComponent, ICustomTypeDescriptor } from "@tsonic/dotnet/System.ComponentModel.js";
-import * as System_Data_Common_Internal from "@tsonic/dotnet/System.Data.Common.js";
-import type { CatalogLocation, DataTableMapping, DbBatch, DbBatchCommand, DbBatchCommandCollection, DbColumn, DbCommand, DbCommandBuilder, DbConnection, DbConnectionStringBuilder, DbDataAdapter, DbDataReader, DbDataSourceEnumerator, DbException, DbParameter, DbParameterCollection, DbProviderFactory, DbTransaction, IDbColumnSchemaGenerator, RowUpdatedEventArgs, RowUpdatingEventArgs } from "@tsonic/dotnet/System.Data.Common.js";
-import * as System_Data_Internal from "@tsonic/dotnet/System.Data.js";
-import type { CommandBehavior, CommandType, ConnectionState, DataRow, DataRowState, DataRowVersion, DataTable, DbType, IDataAdapter, IDataParameter, IDataParameterCollection, IDataReader, IDataRecord, IDbCommand, IDbConnection, IDbDataAdapter, IDbDataParameter, IDbTransaction, IsolationLevel, ParameterDirection, SqlDbType, StatementCompletedEventHandler, StatementType, UpdateRowSource } from "@tsonic/dotnet/System.Data.js";
-import type { SqlBinary, SqlBoolean, SqlByte, SqlBytes, SqlChars, SqlCompareOptions, SqlDateTime, SqlDecimal, SqlDouble, SqlGuid, SqlInt16, SqlInt32, SqlInt64, SqlMoney, SqlSingle, SqlString, SqlXml } from "@tsonic/dotnet/System.Data.SqlTypes.js";
-import type { Stream, TextReader } from "@tsonic/dotnet/System.IO.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Array as ClrArray, AsyncCallback, Boolean as ClrBoolean, Byte, Char, DateTime, DateTimeOffset, Decimal, Double, Enum, EventArgs, EventHandler, Exception, Func, Guid, IAsyncDisposable, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormattable, Int16, Int32, Int64, IntPtr, ISpanFormattable, MulticastDelegate, Nullable, Object as ClrObject, Predicate, Single, String as ClrString, TimeSpan, Type, Uri, ValueType, Void } from "@tsonic/dotnet/System.js";
-import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization.js";
-import type { ISerializable, SerializationInfo, StreamingContext } from "@tsonic/dotnet/System.Runtime.Serialization.js";
-import type { SecureString } from "@tsonic/dotnet/System.Security.js";
-import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
-import type { Task } from "@tsonic/dotnet/System.Threading.Tasks.js";
-import type { XmlReader } from "@tsonic/dotnet/System.Xml.js";
+import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { ICollection_1, IDictionary_2, IEnumerable_1, IEnumerator_1, IList_1, List_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { ReadOnlyCollection_1 } from "@tsonic/dotnet/System.Collections.ObjectModel/internal/index.js";
+import * as System_Collections_Internal from "@tsonic/dotnet/System.Collections/internal/index.js";
+import type { CollectionBase, ICollection, IDictionary, IEnumerable, IEnumerator, IList } from "@tsonic/dotnet/System.Collections/internal/index.js";
+import * as System_ComponentModel_Internal from "@tsonic/dotnet/System.ComponentModel/internal/index.js";
+import type { IComponent, ICustomTypeDescriptor } from "@tsonic/dotnet/System.ComponentModel/internal/index.js";
+import * as System_Data_Common_Internal from "@tsonic/dotnet/System.Data.Common/internal/index.js";
+import type { CatalogLocation, DataTableMapping, DbBatch, DbBatchCommand, DbBatchCommandCollection, DbColumn, DbCommand, DbCommandBuilder, DbConnection, DbConnectionStringBuilder, DbDataAdapter, DbDataReader, DbDataSourceEnumerator, DbException, DbParameter, DbParameterCollection, DbProviderFactory, DbTransaction, IDbColumnSchemaGenerator, RowUpdatedEventArgs, RowUpdatingEventArgs } from "@tsonic/dotnet/System.Data.Common/internal/index.js";
+import type { SqlBinary, SqlBoolean, SqlByte, SqlBytes, SqlChars, SqlCompareOptions, SqlDateTime, SqlDecimal, SqlDouble, SqlGuid, SqlInt16, SqlInt32, SqlInt64, SqlMoney, SqlSingle, SqlString, SqlXml } from "@tsonic/dotnet/System.Data.SqlTypes/internal/index.js";
+import * as System_Data_Internal from "@tsonic/dotnet/System.Data/internal/index.js";
+import type { CommandBehavior, CommandType, ConnectionState, DataRow, DataRowState, DataRowVersion, DataTable, DbType, IDataAdapter, IDataParameter, IDataParameterCollection, IDataReader, IDataRecord, IDbCommand, IDbConnection, IDbDataAdapter, IDbDataParameter, IDbTransaction, IsolationLevel, ParameterDirection, SqlDbType, StatementCompletedEventHandler, StatementType, UpdateRowSource } from "@tsonic/dotnet/System.Data/internal/index.js";
+import type { Stream, TextReader } from "@tsonic/dotnet/System.IO/internal/index.js";
+import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
+import type { ISerializable, SerializationInfo, StreamingContext } from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
+import type { SecureString } from "@tsonic/dotnet/System.Security/internal/index.js";
+import type { Task, Task_1 } from "@tsonic/dotnet/System.Threading.Tasks/internal/index.js";
+import type { CancellationToken } from "@tsonic/dotnet/System.Threading/internal/index.js";
+import type { XmlReader } from "@tsonic/dotnet/System.Xml/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Array as ClrArray, AsyncCallback, Boolean as ClrBoolean, Byte, Char, DateTime, DateTimeOffset, Decimal, Double, Enum, EventArgs, EventHandler_1, Exception, Func_1, Func_2, Func_3, Func_4, Guid, IAsyncDisposable, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormattable, Int16, Int32, Int64, IntPtr, ISpanFormattable, MulticastDelegate, Nullable_1, Object as ClrObject, Predicate_1, Single, String as ClrString, TimeSpan, Type, Uri, ValueType, Void } from "@tsonic/dotnet/System/internal/index.js";
 
 export enum ApplicationIntent {
     ReadWrite = 0,
@@ -178,18 +178,20 @@ export type SqlRowUpdatingEventHandler = (sender: unknown, e: SqlRowUpdatingEven
 
 
 export interface ActiveDirectoryAuthenticationProvider$instance extends SqlAuthenticationProvider {
-    AcquireTokenAsync(parameters: SqlAuthenticationParameters): Task<SqlAuthenticationToken>;
+    readonly __tsonic_type_Microsoft_Data_SqlClient_ActiveDirectoryAuthenticationProvider: never;
+
+    AcquireTokenAsync(parameters: SqlAuthenticationParameters): Task_1<SqlAuthenticationToken>;
     BeforeLoad(authentication: SqlAuthenticationMethod): void;
     BeforeUnload(authentication: SqlAuthenticationMethod): void;
     IsSupported(authentication: SqlAuthenticationMethod): boolean;
-    SetAcquireAuthorizationCodeAsyncCallback(acquireAuthorizationCodeAsyncCallback: Func<Uri, Uri, CancellationToken, Task<Uri>>): void;
-    SetDeviceCodeFlowCallback(deviceCodeFlowCallbackMethod: Func<DeviceCodeResult, Task>): void;
+    SetAcquireAuthorizationCodeAsyncCallback(acquireAuthorizationCodeAsyncCallback: Func_4<Uri, Uri, CancellationToken, Task_1<Uri>>): void;
+    SetDeviceCodeFlowCallback(deviceCodeFlowCallbackMethod: Func_2<DeviceCodeResult, Task>): void;
 }
 
 
 export const ActiveDirectoryAuthenticationProvider: {
     new(): ActiveDirectoryAuthenticationProvider;
-    new(deviceCodeFlowCallbackMethod: Func<DeviceCodeResult, Task>, applicationClientId: string): ActiveDirectoryAuthenticationProvider;
+    new(deviceCodeFlowCallbackMethod: Func_2<DeviceCodeResult, Task>, applicationClientId: string): ActiveDirectoryAuthenticationProvider;
     new(applicationClientId: string): ActiveDirectoryAuthenticationProvider;
     ClearUserTokenCache(): void;
 };
@@ -198,18 +200,21 @@ export const ActiveDirectoryAuthenticationProvider: {
 export type ActiveDirectoryAuthenticationProvider = ActiveDirectoryAuthenticationProvider$instance;
 
 export interface SqlAuthenticationInitializer$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlAuthenticationInitializer: never;
+
     Initialize(): void;
 }
 
 
-export const SqlAuthenticationInitializer: {
-    new(): SqlAuthenticationInitializer;
+export const SqlAuthenticationInitializer: (abstract new() => SqlAuthenticationInitializer) & {
 };
 
 
 export type SqlAuthenticationInitializer = SqlAuthenticationInitializer$instance;
 
 export interface SqlAuthenticationParameters$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlAuthenticationParameters: never;
+
     readonly AuthenticationMethod: SqlAuthenticationMethod;
     readonly Authority: string;
     readonly ConnectionId: Guid;
@@ -222,23 +227,23 @@ export interface SqlAuthenticationParameters$instance {
 }
 
 
-export const SqlAuthenticationParameters: {
-    new(authenticationMethod: SqlAuthenticationMethod, serverName: string, databaseName: string, resource: string, authority: string, userId: string, password: string, connectionId: Guid, connectionTimeout: int): SqlAuthenticationParameters;
+export const SqlAuthenticationParameters: (abstract new(authenticationMethod: SqlAuthenticationMethod, serverName: string, databaseName: string, resource: string, authority: string, userId: string, password: string, connectionId: Guid, connectionTimeout: int) => SqlAuthenticationParameters) & {
 };
 
 
 export type SqlAuthenticationParameters = SqlAuthenticationParameters$instance;
 
 export interface SqlAuthenticationProvider$instance {
-    AcquireTokenAsync(parameters: SqlAuthenticationParameters): Task<SqlAuthenticationToken>;
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlAuthenticationProvider: never;
+
+    AcquireTokenAsync(parameters: SqlAuthenticationParameters): Task_1<SqlAuthenticationToken>;
     BeforeLoad(authenticationMethod: SqlAuthenticationMethod): void;
     BeforeUnload(authenticationMethod: SqlAuthenticationMethod): void;
     IsSupported(authenticationMethod: SqlAuthenticationMethod): boolean;
 }
 
 
-export const SqlAuthenticationProvider: {
-    new(): SqlAuthenticationProvider;
+export const SqlAuthenticationProvider: (abstract new() => SqlAuthenticationProvider) & {
     GetProvider(authenticationMethod: SqlAuthenticationMethod): SqlAuthenticationProvider;
     SetProvider(authenticationMethod: SqlAuthenticationMethod, provider: SqlAuthenticationProvider): boolean;
 };
@@ -247,6 +252,8 @@ export const SqlAuthenticationProvider: {
 export type SqlAuthenticationProvider = SqlAuthenticationProvider$instance;
 
 export interface SqlAuthenticationToken$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlAuthenticationToken: never;
+
     readonly AccessToken: string;
     readonly ExpiresOn: DateTimeOffset;
 }
@@ -259,30 +266,31 @@ export const SqlAuthenticationToken: {
 
 export type SqlAuthenticationToken = SqlAuthenticationToken$instance;
 
-export abstract class SqlBatch$protected {
-    protected readonly DbBatchCommands: DbBatchCommandCollection;
-    protected DbConnection: DbConnection;
-    protected DbTransaction: DbTransaction;
-    protected CreateDbBatchCommand(): DbBatchCommand;
-    protected ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
-    protected ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task<DbDataReader>;
-}
+export interface SqlBatch$instance extends DbBatch {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlBatch: never;
 
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqlBatch$instance extends SqlBatch$protected, DbBatch {
     readonly BatchCommands: SqlBatchCommandCollection;
-    readonly Commands: List<SqlBatchCommand>;
+    readonly Commands: List_1<SqlBatchCommand>;
     Connection: SqlConnection;
+    readonly DbBatchCommands: DbBatchCommandCollection;
+    DbConnection: DbConnection;
+    DbTransaction: DbTransaction;
     Timeout: int;
     Transaction: SqlTransaction;
     Cancel(): void;
+    CreateDbBatchCommand(): DbBatchCommand;
     Dispose(): void;
+    ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
+    ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task_1<DbDataReader>;
     ExecuteNonQuery(): int;
-    ExecuteNonQueryAsync(cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
+    ExecuteNonQueryAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
     ExecuteReader(): SqlDataReader;
-    ExecuteReaderAsync(cancellationToken?: CancellationToken): Task<SqlDataReader>;
+    ExecuteReaderAsync(cancellationToken?: CancellationToken): Task_1<SqlDataReader>;
     ExecuteScalar(): unknown;
-    ExecuteScalarAsync(cancellationToken?: CancellationToken): Task<unknown>;
+    ExecuteScalarAsync(cancellationToken?: CancellationToken): Task_1<unknown>;
     Prepare(): void;
     PrepareAsync(cancellationToken?: CancellationToken): Task;
 }
@@ -296,16 +304,14 @@ export const SqlBatch: {
 
 export type SqlBatch = SqlBatch$instance;
 
-export abstract class SqlBatchCommand$protected {
-    protected readonly DbParameterCollection: DbParameterCollection;
-}
-
+export interface SqlBatchCommand$instance extends DbBatchCommand {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlBatchCommand: never;
 
-export interface SqlBatchCommand$instance extends SqlBatchCommand$protected, DbBatchCommand {
     ColumnEncryptionSetting: SqlCommandColumnEncryptionSetting;
     CommandBehavior: CommandBehavior;
     CommandText: string;
     CommandType: CommandType;
+    readonly DbParameterCollection: DbParameterCollection;
     readonly Parameters: SqlParameterCollection;
     readonly RecordsAffected: int;
 }
@@ -313,22 +319,23 @@ export interface SqlBatchCommand$instance extends SqlBatchCommand$protected, DbB
 
 export const SqlBatchCommand: {
     new(): SqlBatchCommand;
-    new(commandText: string, commandType: CommandType, parameters: IEnumerable__System_Collections_Generic<SqlParameter>, columnEncryptionSetting: SqlCommandColumnEncryptionSetting): SqlBatchCommand;
+    new(commandText: string, commandType: CommandType, parameters: IEnumerable_1<SqlParameter>, columnEncryptionSetting: SqlCommandColumnEncryptionSetting): SqlBatchCommand;
 };
 
 
 export type SqlBatchCommand = SqlBatchCommand$instance;
 
-export abstract class SqlBatchCommandCollection$protected {
-    protected GetBatchCommand(index: int): DbBatchCommand;
-    protected SetBatchCommand(index: int, batchCommand: DbBatchCommand): void;
-}
+export interface SqlBatchCommandCollection$instance extends DbBatchCommandCollection {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlBatchCommandCollection: never;
 
+    readonly __tsonic_iface_System_Collections_Generic_ICollection_1: never;
+    readonly __tsonic_iface_System_Collections_Generic_IEnumerable_1: never;
+    readonly __tsonic_iface_System_Collections_Generic_IList_1: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
 
-export interface SqlBatchCommandCollection$instance extends SqlBatchCommandCollection$protected, DbBatchCommandCollection {
     readonly Count: int;
     readonly IsReadOnly: boolean;
-    Item: SqlBatchCommand;
+    [index: number]: SqlBatchCommand;
     Add(item: SqlBatchCommand): void;
     Add(item: DbBatchCommand): void;
     Clear(): void;
@@ -336,7 +343,8 @@ export interface SqlBatchCommandCollection$instance extends SqlBatchCommandColle
     Contains(item: DbBatchCommand): boolean;
     CopyTo(array: SqlBatchCommand[], arrayIndex: int): void;
     CopyTo(array: DbBatchCommand[], arrayIndex: int): void;
-    GetEnumerator(): IEnumerator__System_Collections_Generic<DbBatchCommand>;
+    GetBatchCommand(index: int): DbBatchCommand;
+    GetEnumerator(): IEnumerator_1<DbBatchCommand>;
     IndexOf(item: SqlBatchCommand): int;
     IndexOf(item: DbBatchCommand): int;
     Insert(index: int, item: SqlBatchCommand): void;
@@ -344,6 +352,7 @@ export interface SqlBatchCommandCollection$instance extends SqlBatchCommandColle
     Remove(item: SqlBatchCommand): boolean;
     Remove(item: DbBatchCommand): boolean;
     RemoveAt(index: int): void;
+    SetBatchCommand(index: int, batchCommand: DbBatchCommand): void;
 }
 
 
@@ -355,6 +364,10 @@ export const SqlBatchCommandCollection: {
 export type SqlBatchCommandCollection = SqlBatchCommandCollection$instance;
 
 export interface SqlBulkCopy$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlBulkCopy: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     BatchSize: int;
     BulkCopyTimeout: int;
     readonly ColumnMappings: SqlBulkCopyColumnMappingCollection;
@@ -394,6 +407,8 @@ export const SqlBulkCopy: {
 export type SqlBulkCopy = SqlBulkCopy$instance;
 
 export interface SqlBulkCopyColumnMapping$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlBulkCopyColumnMapping: never;
+
     DestinationColumn: string;
     DestinationOrdinal: int;
     SourceColumn: string;
@@ -413,7 +428,13 @@ export const SqlBulkCopyColumnMapping: {
 export type SqlBulkCopyColumnMapping = SqlBulkCopyColumnMapping$instance;
 
 export interface SqlBulkCopyColumnMappingCollection$instance extends CollectionBase {
-    readonly Item: SqlBulkCopyColumnMapping;
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlBulkCopyColumnMappingCollection: never;
+
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Collections_IList: never;
+
+    readonly [index: number]: SqlBulkCopyColumnMapping;
     Add(bulkCopyColumnMapping: SqlBulkCopyColumnMapping): SqlBulkCopyColumnMapping;
     Add(sourceColumnIndex: int, destinationColumnIndex: int): SqlBulkCopyColumnMapping;
     Add(sourceColumnIndex: int, destinationColumn: string): SqlBulkCopyColumnMapping;
@@ -430,13 +451,14 @@ export interface SqlBulkCopyColumnMappingCollection$instance extends CollectionB
 
 
 export const SqlBulkCopyColumnMappingCollection: {
-    new(): SqlBulkCopyColumnMappingCollection;
 };
 
 
 export type SqlBulkCopyColumnMappingCollection = SqlBulkCopyColumnMappingCollection$instance;
 
 export interface SqlBulkCopyColumnOrderHint$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlBulkCopyColumnOrderHint: never;
+
     Column: string;
     SortOrder: SortOrder;
 }
@@ -450,7 +472,13 @@ export const SqlBulkCopyColumnOrderHint: {
 export type SqlBulkCopyColumnOrderHint = SqlBulkCopyColumnOrderHint$instance;
 
 export interface SqlBulkCopyColumnOrderHintCollection$instance extends CollectionBase {
-    readonly Item: SqlBulkCopyColumnOrderHint;
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlBulkCopyColumnOrderHintCollection: never;
+
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Collections_IList: never;
+
+    readonly [index: number]: SqlBulkCopyColumnOrderHint;
     Add(columnOrderHint: SqlBulkCopyColumnOrderHint): SqlBulkCopyColumnOrderHint;
     Add(column: string, sortOrder: SortOrder): SqlBulkCopyColumnOrderHint;
     Clear(): void;
@@ -471,6 +499,8 @@ export const SqlBulkCopyColumnOrderHintCollection: {
 export type SqlBulkCopyColumnOrderHintCollection = SqlBulkCopyColumnOrderHintCollection$instance;
 
 export interface SqlClientFactory$instance extends DbProviderFactory {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlClientFactory: never;
+
     readonly CanCreateBatch: boolean;
     CreateBatch(): DbBatch;
     CreateBatchCommand(): DbBatchCommand;
@@ -485,7 +515,6 @@ export interface SqlClientFactory$instance extends DbProviderFactory {
 
 
 export const SqlClientFactory: {
-    new(): SqlClientFactory;
     readonly Instance: SqlClientFactory;
 };
 
@@ -493,6 +522,8 @@ export const SqlClientFactory: {
 export type SqlClientFactory = SqlClientFactory$instance;
 
 export interface SqlClientLogger$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlClientLogger: never;
+
     readonly IsLoggingEnabled: boolean;
     LogAssert(value: boolean, type: string, method: string, message: string): boolean;
     LogError(type: string, method: string, message: string): void;
@@ -509,6 +540,8 @@ export const SqlClientLogger: {
 export type SqlClientLogger = SqlClientLogger$instance;
 
 export interface SqlColumnEncryptionCertificateStoreProvider$instance extends SqlColumnEncryptionKeyStoreProvider {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlColumnEncryptionCertificateStoreProvider: never;
+
     DecryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, encryptedColumnEncryptionKey: byte[]): byte[];
     EncryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, columnEncryptionKey: byte[]): byte[];
     SignColumnMasterKeyMetadata(masterKeyPath: string, allowEnclaveComputations: boolean): byte[];
@@ -525,6 +558,8 @@ export const SqlColumnEncryptionCertificateStoreProvider: {
 export type SqlColumnEncryptionCertificateStoreProvider = SqlColumnEncryptionCertificateStoreProvider$instance;
 
 export interface SqlColumnEncryptionCngProvider$instance extends SqlColumnEncryptionKeyStoreProvider {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlColumnEncryptionCngProvider: never;
+
     DecryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, encryptedColumnEncryptionKey: byte[]): byte[];
     EncryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, columnEncryptionKey: byte[]): byte[];
     SignColumnMasterKeyMetadata(masterKeyPath: string, allowEnclaveComputations: boolean): byte[];
@@ -541,6 +576,8 @@ export const SqlColumnEncryptionCngProvider: {
 export type SqlColumnEncryptionCngProvider = SqlColumnEncryptionCngProvider$instance;
 
 export interface SqlColumnEncryptionCspProvider$instance extends SqlColumnEncryptionKeyStoreProvider {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlColumnEncryptionCspProvider: never;
+
     DecryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, encryptedColumnEncryptionKey: byte[]): byte[];
     EncryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, columnEncryptionKey: byte[]): byte[];
     SignColumnMasterKeyMetadata(masterKeyPath: string, allowEnclaveComputations: boolean): byte[];
@@ -557,7 +594,9 @@ export const SqlColumnEncryptionCspProvider: {
 export type SqlColumnEncryptionCspProvider = SqlColumnEncryptionCspProvider$instance;
 
 export interface SqlColumnEncryptionKeyStoreProvider$instance {
-    ColumnEncryptionKeyCacheTtl: Nullable<TimeSpan>;
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlColumnEncryptionKeyStoreProvider: never;
+
+    ColumnEncryptionKeyCacheTtl: Nullable_1<TimeSpan>;
     DecryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, encryptedColumnEncryptionKey: byte[]): byte[];
     EncryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, columnEncryptionKey: byte[]): byte[];
     SignColumnMasterKeyMetadata(masterKeyPath: string, allowEnclaveComputations: boolean): byte[];
@@ -565,30 +604,29 @@ export interface SqlColumnEncryptionKeyStoreProvider$instance {
 }
 
 
-export const SqlColumnEncryptionKeyStoreProvider: {
-    new(): SqlColumnEncryptionKeyStoreProvider;
+export const SqlColumnEncryptionKeyStoreProvider: (abstract new() => SqlColumnEncryptionKeyStoreProvider) & {
 };
 
 
 export type SqlColumnEncryptionKeyStoreProvider = SqlColumnEncryptionKeyStoreProvider$instance;
 
-export abstract class SqlCommand$protected {
-    protected DbConnection: DbConnection;
-    protected readonly DbParameterCollection: DbParameterCollection;
-    protected DbTransaction: DbTransaction;
-    protected CreateDbParameter(): DbParameter;
-    protected Dispose(disposing: boolean): void;
-    protected ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
-    protected ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task<DbDataReader>;
-}
+export interface SqlCommand$instance extends DbCommand {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlCommand: never;
 
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_Data_IDbCommand: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqlCommand$instance extends SqlCommand$protected, DbCommand {
     readonly ColumnEncryptionSetting: SqlCommandColumnEncryptionSetting;
     CommandText: string;
     CommandTimeout: int;
     CommandType: CommandType;
     Connection: SqlConnection;
+    DbConnection: DbConnection;
+    readonly DbParameterCollection: DbParameterCollection;
+    DbTransaction: DbTransaction;
     DesignTimeVisible: boolean;
     EnableOptimizedParameterBinding: boolean;
     Notification: SqlNotificationRequest;
@@ -606,25 +644,29 @@ export interface SqlCommand$instance extends SqlCommand$protected, DbCommand {
     BeginExecuteXmlReader(callback: AsyncCallback, stateObject: unknown): IAsyncResult;
     Cancel(): void;
     Clone(): SqlCommand;
+    CreateDbParameter(): DbParameter;
     CreateParameter(): SqlParameter;
+    Dispose(disposing: boolean): void;
     EndExecuteNonQuery(asyncResult: IAsyncResult): int;
     EndExecuteReader(asyncResult: IAsyncResult): SqlDataReader;
     EndExecuteXmlReader(asyncResult: IAsyncResult): XmlReader;
+    ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
+    ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task_1<DbDataReader>;
     ExecuteNonQuery(): int;
-    ExecuteNonQueryAsync(cancellationToken: CancellationToken): Task<System_Internal.Int32>;
+    ExecuteNonQueryAsync(cancellationToken: CancellationToken): Task_1<System_Internal.Int32>;
     ExecuteReader(): SqlDataReader;
     ExecuteReader(behavior: CommandBehavior): SqlDataReader;
-    ExecuteReaderAsync(): Task<SqlDataReader>;
-    ExecuteReaderAsync(behavior: CommandBehavior): Task<SqlDataReader>;
-    ExecuteReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task<SqlDataReader>;
-    ExecuteReaderAsync(cancellationToken: CancellationToken): Task<SqlDataReader>;
+    ExecuteReaderAsync(): Task_1<SqlDataReader>;
+    ExecuteReaderAsync(behavior: CommandBehavior): Task_1<SqlDataReader>;
+    ExecuteReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task_1<SqlDataReader>;
+    ExecuteReaderAsync(cancellationToken: CancellationToken): Task_1<SqlDataReader>;
     ExecuteScalar(): unknown;
-    ExecuteScalarAsync(cancellationToken: CancellationToken): Task<unknown>;
+    ExecuteScalarAsync(cancellationToken: CancellationToken): Task_1<unknown>;
     ExecuteXmlReader(): XmlReader;
-    ExecuteXmlReaderAsync(): Task<XmlReader>;
-    ExecuteXmlReaderAsync(cancellationToken: CancellationToken): Task<XmlReader>;
+    ExecuteXmlReaderAsync(): Task_1<XmlReader>;
+    ExecuteXmlReaderAsync(cancellationToken: CancellationToken): Task_1<XmlReader>;
     Prepare(): void;
-    RegisterColumnEncryptionKeyStoreProvidersOnCommand(customProviders: IDictionary__System_Collections_Generic<System_Internal.String, SqlColumnEncryptionKeyStoreProvider>): void;
+    RegisterColumnEncryptionKeyStoreProvidersOnCommand(customProviders: IDictionary_2<System_Internal.String, SqlColumnEncryptionKeyStoreProvider>): void;
     ResetCommandTimeout(): void;
 }
 
@@ -640,31 +682,32 @@ export const SqlCommand: {
 
 export type SqlCommand = SqlCommand$instance;
 
-export abstract class SqlCommandBuilder$protected {
-    protected ApplyParameterInfo(parameter: DbParameter, datarow: DataRow, statementType: StatementType, whereClause: boolean): void;
-    protected GetParameterName(parameterOrdinal: int): string;
-    protected GetParameterName(parameterName: string): string;
-    protected GetParameterPlaceholder(parameterOrdinal: int): string;
-    protected GetSchemaTable(srcCommand: DbCommand): DataTable;
-    protected InitializeCommand(command: DbCommand): DbCommand;
-    protected SetRowUpdatingHandler(adapter: DbDataAdapter): void;
-}
+export interface SqlCommandBuilder$instance extends DbCommandBuilder {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlCommandBuilder: never;
 
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqlCommandBuilder$instance extends SqlCommandBuilder$protected, DbCommandBuilder {
     CatalogLocation: CatalogLocation;
     CatalogSeparator: string;
     DataAdapter: SqlDataAdapter;
     QuotePrefix: string;
     QuoteSuffix: string;
     SchemaSeparator: string;
+    ApplyParameterInfo(parameter: DbParameter, datarow: DataRow, statementType: StatementType, whereClause: boolean): void;
     GetDeleteCommand(): SqlCommand;
     GetDeleteCommand(useColumnsForParameterNames: boolean): SqlCommand;
     GetInsertCommand(): SqlCommand;
     GetInsertCommand(useColumnsForParameterNames: boolean): SqlCommand;
+    GetParameterName(parameterOrdinal: int): string;
+    GetParameterName(parameterName: string): string;
+    GetParameterPlaceholder(parameterOrdinal: int): string;
+    GetSchemaTable(srcCommand: DbCommand): DataTable;
     GetUpdateCommand(): SqlCommand;
     GetUpdateCommand(useColumnsForParameterNames: boolean): SqlCommand;
+    InitializeCommand(command: DbCommand): DbCommand;
     QuoteIdentifier(unquotedIdentifier: string): string;
+    SetRowUpdatingHandler(adapter: DbDataAdapter): void;
     UnquoteIdentifier(quotedIdentifier: string): string;
 }
 
@@ -679,6 +722,8 @@ export const SqlCommandBuilder: {
 export type SqlCommandBuilder = SqlCommandBuilder$instance;
 
 export interface SqlConfigurableRetryFactory$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlConfigurableRetryFactory: never;
+
 }
 
 
@@ -693,22 +738,21 @@ export const SqlConfigurableRetryFactory: {
 
 export type SqlConfigurableRetryFactory = SqlConfigurableRetryFactory$instance;
 
-export abstract class SqlConnection$protected {
-    protected BeginDbTransaction(isolationLevel: IsolationLevel): DbTransaction;
-    protected CreateDbBatch(): DbBatch;
-    protected CreateDbCommand(): DbCommand;
-    protected Dispose(disposing: boolean): void;
-}
+export interface SqlConnection$instance extends DbConnection {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlConnection: never;
 
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_Data_IDbConnection: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqlConnection$instance extends SqlConnection$protected, DbConnection {
     AccessToken: string;
-    AccessTokenCallback: Func<SqlAuthenticationParameters, CancellationToken, Task<SqlAuthenticationToken>>;
+    AccessTokenCallback: Func_3<SqlAuthenticationParameters, CancellationToken, Task_1<SqlAuthenticationToken>>;
     readonly CanCreateBatch: boolean;
     readonly ClientConnectionId: Guid;
     readonly CommandTimeout: int;
-    get ConnectionString(): string | undefined;
-    set ConnectionString(value: string);
+    ConnectionString: string;
     readonly ConnectionTimeout: int;
     Credential: SqlCredential;
     readonly Database: string;
@@ -721,6 +765,7 @@ export interface SqlConnection$instance extends SqlConnection$protected, DbConne
     readonly State: ConnectionState;
     StatisticsEnabled: boolean;
     readonly WorkstationId: string;
+    BeginDbTransaction(isolationLevel: IsolationLevel): DbTransaction;
     BeginTransaction(): SqlTransaction;
     BeginTransaction(iso: IsolationLevel): SqlTransaction;
     BeginTransaction(iso: IsolationLevel, transactionName: string): SqlTransaction;
@@ -728,6 +773,9 @@ export interface SqlConnection$instance extends SqlConnection$protected, DbConne
     ChangeDatabase(database: string): void;
     Close(): void;
     CreateCommand(): SqlCommand;
+    CreateDbBatch(): DbBatch;
+    CreateDbCommand(): DbCommand;
+    Dispose(disposing: boolean): void;
     GetSchema(): DataTable;
     GetSchema(collectionName: string): DataTable;
     GetSchema(collectionName: string, restrictionValues: string[]): DataTable;
@@ -735,9 +783,9 @@ export interface SqlConnection$instance extends SqlConnection$protected, DbConne
     Open(overrides: SqlConnectionOverrides): void;
     OpenAsync(overrides: SqlConnectionOverrides, cancellationToken: CancellationToken): Task;
     OpenAsync(cancellationToken: CancellationToken): Task;
-    RegisterColumnEncryptionKeyStoreProvidersOnConnection(customProviders: IDictionary__System_Collections_Generic<System_Internal.String, SqlColumnEncryptionKeyStoreProvider>): void;
+    RegisterColumnEncryptionKeyStoreProvidersOnConnection(customProviders: IDictionary_2<System_Internal.String, SqlColumnEncryptionKeyStoreProvider>): void;
     ResetStatistics(): void;
-    RetrieveInternalInfo(): IDictionary__System_Collections_Generic<System_Internal.String, unknown>;
+    RetrieveInternalInfo(): IDictionary_2<System_Internal.String, unknown>;
     RetrieveStatistics(): IDictionary;
 }
 
@@ -748,21 +796,23 @@ export const SqlConnection: {
     new(connectionString: string, credential: SqlCredential): SqlConnection;
     ColumnEncryptionKeyCacheTtl: TimeSpan;
     ColumnEncryptionQueryMetadataCacheEnabled: boolean;
-    readonly ColumnEncryptionTrustedMasterKeyPaths: IDictionary__System_Collections_Generic<System_Internal.String, IList__System_Collections_Generic<System_Internal.String>>;
+    readonly ColumnEncryptionTrustedMasterKeyPaths: IDictionary_2<System_Internal.String, IList_1<System_Internal.String>>;
     ChangePassword(connectionString: string, credential: SqlCredential, newSecurePassword: SecureString): void;
     ChangePassword(connectionString: string, newPassword: string): void;
     ClearAllPools(): void;
     ClearPool(connection: SqlConnection): void;
-    RegisterColumnEncryptionKeyStoreProviders(customProviders: IDictionary__System_Collections_Generic<System_Internal.String, SqlColumnEncryptionKeyStoreProvider>): void;
+    RegisterColumnEncryptionKeyStoreProviders(customProviders: IDictionary_2<System_Internal.String, SqlColumnEncryptionKeyStoreProvider>): void;
 };
 
 
 export type SqlConnection = SqlConnection$instance;
 
 export interface SqlConnectionEncryptOption$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlConnectionEncryptOption: never;
+
     Equals(obj: unknown): boolean;
     GetHashCode(): int;
-    ToString(): string | undefined;
+    ToString(): string;
 }
 
 
@@ -779,6 +829,13 @@ export const SqlConnectionEncryptOption: {
 export type SqlConnectionEncryptOption = SqlConnectionEncryptOption$instance;
 
 export interface SqlConnectionStringBuilder$instance extends DbConnectionStringBuilder {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlConnectionStringBuilder: never;
+
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IDictionary: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_ComponentModel_ICustomTypeDescriptor: never;
+
     ApplicationIntent: ApplicationIntent;
     ApplicationName: string;
     AttachDBFilename: string;
@@ -801,7 +858,7 @@ export interface SqlConnectionStringBuilder$instance extends DbConnectionStringB
     IntegratedSecurity: boolean;
     IPAddressPreference: SqlConnectionIPAddressPreference;
     readonly IsFixedSize: boolean;
-    Item: unknown;
+    [keyword: string]: unknown;
     readonly Keys: ICollection;
     LoadBalanceTimeout: int;
     MaxPoolSize: int;
@@ -840,6 +897,8 @@ export const SqlConnectionStringBuilder: {
 export type SqlConnectionStringBuilder = SqlConnectionStringBuilder$instance;
 
 export interface SqlCredential$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlCredential: never;
+
     readonly Password: SecureString;
     readonly UserId: string;
 }
@@ -852,18 +911,22 @@ export const SqlCredential: {
 
 export type SqlCredential = SqlCredential$instance;
 
-export abstract class SqlDataAdapter$protected {
-    protected OnRowUpdated(value: RowUpdatedEventArgs): void;
-    protected OnRowUpdating(value: RowUpdatingEventArgs): void;
-}
+export interface SqlDataAdapter$instance extends DbDataAdapter {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlDataAdapter: never;
 
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_Data_IDataAdapter: never;
+    readonly __tsonic_iface_System_Data_IDbDataAdapter: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqlDataAdapter$instance extends SqlDataAdapter$protected, DbDataAdapter {
     DeleteCommand: SqlCommand;
     InsertCommand: SqlCommand;
     SelectCommand: SqlCommand;
     UpdateBatchSize: int;
     UpdateCommand: SqlCommand;
+    OnRowUpdated(value: RowUpdatedEventArgs): void;
+    OnRowUpdating(value: RowUpdatingEventArgs): void;
 }
 
 
@@ -878,6 +941,15 @@ export const SqlDataAdapter: {
 export type SqlDataAdapter = SqlDataAdapter$instance;
 
 export interface SqlDataReader$instance extends DbDataReader {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlDataReader: never;
+
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Data_Common_IDbColumnSchemaGenerator: never;
+    readonly __tsonic_iface_System_Data_IDataReader: never;
+    readonly __tsonic_iface_System_Data_IDataRecord: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly Depth: int;
     readonly FieldCount: int;
     readonly HasRows: boolean;
@@ -893,7 +965,7 @@ export interface SqlDataReader$instance extends DbDataReader {
     GetBytes(i: int, dataIndex: long, buffer: byte[], bufferIndex: int, length: int): long;
     GetChar(i: int): char;
     GetChars(i: int, dataIndex: long, buffer: char[], bufferIndex: int, length: int): long;
-    GetColumnSchema(): ReadOnlyCollection<DbColumn>;
+    GetColumnSchema(): ReadOnlyCollection_1<DbColumn>;
     GetDataTypeName(i: int): string;
     GetDateTime(i: int): DateTime;
     GetDateTimeOffset(i: int): DateTimeOffset;
@@ -902,7 +974,7 @@ export interface SqlDataReader$instance extends DbDataReader {
     GetEnumerator(): IEnumerator;
     GetFieldType(i: int): Type;
     GetFieldValue<T>(i: int): T;
-    GetFieldValueAsync<T>(i: int, cancellationToken: CancellationToken): Task<T>;
+    GetFieldValueAsync<T>(i: int, cancellationToken: CancellationToken): Task_1<T>;
     GetFloat(i: int): float;
     GetGuid(i: int): Guid;
     GetInt16(i: int): short;
@@ -942,22 +1014,23 @@ export interface SqlDataReader$instance extends DbDataReader {
     GetValues(values: unknown[]): int;
     GetXmlReader(i: int): XmlReader;
     IsDBNull(i: int): boolean;
-    IsDBNullAsync(i: int, cancellationToken: CancellationToken): Task<System_Internal.Boolean>;
+    IsDBNullAsync(i: int, cancellationToken: CancellationToken): Task_1<System_Internal.Boolean>;
     NextResult(): boolean;
-    NextResultAsync(cancellationToken: CancellationToken): Task<System_Internal.Boolean>;
+    NextResultAsync(cancellationToken: CancellationToken): Task_1<System_Internal.Boolean>;
     Read(): boolean;
-    ReadAsync(cancellationToken: CancellationToken): Task<System_Internal.Boolean>;
+    ReadAsync(cancellationToken: CancellationToken): Task_1<System_Internal.Boolean>;
 }
 
 
 export const SqlDataReader: {
-    new(): SqlDataReader;
 };
 
 
 export type SqlDataReader = SqlDataReader$instance;
 
 export interface SqlDependency$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlDependency: never;
+
     readonly HasChanges: boolean;
     readonly Id: string;
     AddCommandDependency(command: SqlCommand): void;
@@ -978,28 +1051,34 @@ export const SqlDependency: {
 export type SqlDependency = SqlDependency$instance;
 
 export interface SqlError$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlError: never;
+
     readonly Class: byte;
     readonly LineNumber: int;
-    readonly Message: string | undefined;
+    readonly Message: string;
     readonly Number: int;
     readonly Procedure: string;
     readonly Server: string;
     readonly Source: string;
     readonly State: byte;
-    ToString(): string | undefined;
+    ToString(): string;
 }
 
 
 export const SqlError: {
-    new(): SqlError;
 };
 
 
 export type SqlError = SqlError$instance;
 
 export interface SqlErrorCollection$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlErrorCollection: never;
+
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+
     readonly Count: int;
-    readonly Item: SqlError;
+    readonly [index: number]: SqlError;
     CopyTo(array: SqlError[], index: int): void;
     CopyTo(array: ClrArray, index: int): void;
     GetEnumerator(): IEnumerator;
@@ -1007,21 +1086,20 @@ export interface SqlErrorCollection$instance {
 
 
 export const SqlErrorCollection: {
-    new(): SqlErrorCollection;
 };
 
 
 export type SqlErrorCollection = SqlErrorCollection$instance;
 
-export abstract class SqlException$protected {
-    protected readonly DbBatchCommand: DbBatchCommand;
-}
+export interface SqlException$instance extends DbException {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlException: never;
 
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
-export interface SqlException$instance extends SqlException$protected, DbException {
     readonly BatchCommand: SqlBatchCommand;
     readonly Class: byte;
     readonly ClientConnectionId: Guid;
+    readonly DbBatchCommand: DbBatchCommand;
     readonly Errors: SqlErrorCollection;
     readonly LineNumber: int;
     readonly Number: int;
@@ -1035,13 +1113,14 @@ export interface SqlException$instance extends SqlException$protected, DbExcepti
 
 
 export const SqlException: {
-    new(): SqlException;
 };
 
 
 export type SqlException = SqlException$instance;
 
 export interface SqlInfoMessageEventArgs$instance extends EventArgs {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlInfoMessageEventArgs: never;
+
     readonly Errors: SqlErrorCollection;
     readonly Message: string;
     readonly Source: string;
@@ -1050,13 +1129,14 @@ export interface SqlInfoMessageEventArgs$instance extends EventArgs {
 
 
 export const SqlInfoMessageEventArgs: {
-    new(): SqlInfoMessageEventArgs;
 };
 
 
 export type SqlInfoMessageEventArgs = SqlInfoMessageEventArgs$instance;
 
 export interface SqlNotificationEventArgs$instance extends EventArgs {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlNotificationEventArgs: never;
+
     readonly Info: SqlNotificationInfo;
     readonly Source: SqlNotificationSource;
     readonly Type: SqlNotificationType;
@@ -1071,6 +1151,12 @@ export const SqlNotificationEventArgs: {
 export type SqlNotificationEventArgs = SqlNotificationEventArgs$instance;
 
 export interface SqlParameter$instance extends DbParameter {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlParameter: never;
+
+    readonly __tsonic_iface_System_Data_IDataParameter: never;
+    readonly __tsonic_iface_System_Data_IDbDataParameter: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+
     CompareInfo: SqlCompareOptions;
     DbType: DbType;
     Direction: ParameterDirection;
@@ -1112,15 +1198,14 @@ export const SqlParameter: {
 
 export type SqlParameter = SqlParameter$instance;
 
-export abstract class SqlParameterCollection$protected {
-    protected GetParameter(index: int): DbParameter;
-    protected GetParameter(parameterName: string): DbParameter;
-    protected SetParameter(index: int, value: DbParameter): void;
-    protected SetParameter(parameterName: string, value: DbParameter): void;
-}
+export interface SqlParameterCollection$instance extends DbParameterCollection {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlParameterCollection: never;
 
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Collections_IList: never;
+    readonly __tsonic_iface_System_Data_IDataParameterCollection: never;
 
-export interface SqlParameterCollection$instance extends SqlParameterCollection$protected, DbParameterCollection {
     readonly Count: int;
     readonly IsFixedSize: boolean;
     readonly IsReadOnly: boolean;
@@ -1142,6 +1227,8 @@ export interface SqlParameterCollection$instance extends SqlParameterCollection$
     get_Item(index: int): SqlParameter;
     get_Item(parameterName: string): SqlParameter;
     GetEnumerator(): IEnumerator;
+    GetParameter(index: int): DbParameter;
+    GetParameter(parameterName: string): DbParameter;
     IndexOf(value: SqlParameter): int;
     IndexOf(value: unknown): int;
     IndexOf(parameterName: string): int;
@@ -1153,62 +1240,70 @@ export interface SqlParameterCollection$instance extends SqlParameterCollection$
     RemoveAt(parameterName: string): void;
     set_Item(index: int, value: SqlParameter): void;
     set_Item(parameterName: string, value: SqlParameter): void;
+    SetParameter(index: int, value: DbParameter): void;
+    SetParameter(parameterName: string, value: DbParameter): void;
 }
 
 
 export const SqlParameterCollection: {
-    new(): SqlParameterCollection;
 };
 
 
 export type SqlParameterCollection = SqlParameterCollection$instance;
 
 export interface SqlRetryingEventArgs$instance extends EventArgs {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlRetryingEventArgs: never;
+
     Cancel: boolean;
     readonly Delay: TimeSpan;
-    readonly Exceptions: IList__System_Collections_Generic<Exception>;
+    readonly Exceptions: IList_1<Exception>;
     readonly RetryCount: int;
 }
 
 
 export const SqlRetryingEventArgs: {
-    new(retryCount: int, delay: TimeSpan, exceptions: IList__System_Collections_Generic<Exception>): SqlRetryingEventArgs;
+    new(retryCount: int, delay: TimeSpan, exceptions: IList_1<Exception>): SqlRetryingEventArgs;
 };
 
 
 export type SqlRetryingEventArgs = SqlRetryingEventArgs$instance;
 
-export abstract class SqlRetryIntervalBaseEnumerator$protected {
-    protected abstract GetNextInterval(): TimeSpan;
-    protected Validate(timeInterval: TimeSpan, maxTimeInterval: TimeSpan, minTimeInterval: TimeSpan): void;
-}
+export interface SqlRetryIntervalBaseEnumerator$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlRetryIntervalBaseEnumerator: never;
 
+    readonly __tsonic_iface_System_Collections_Generic_IEnumerator_1: never;
+    readonly __tsonic_iface_System_Collections_IEnumerator: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqlRetryIntervalBaseEnumerator$instance extends SqlRetryIntervalBaseEnumerator$protected {
     Current: TimeSpan;
     GapTimeInterval: TimeSpan;
     MaxTimeInterval: TimeSpan;
     MinTimeInterval: TimeSpan;
     Clone(): unknown;
     Dispose(): void;
+    GetNextInterval(): TimeSpan;
     MoveNext(): boolean;
     Reset(): void;
+    Validate(timeInterval: TimeSpan, maxTimeInterval: TimeSpan, minTimeInterval: TimeSpan): void;
 }
 
 
-export const SqlRetryIntervalBaseEnumerator: {
-    new(): SqlRetryIntervalBaseEnumerator;
-    new(timeInterval: TimeSpan, maxTime: TimeSpan, minTime: TimeSpan): SqlRetryIntervalBaseEnumerator;
+export const SqlRetryIntervalBaseEnumerator: (abstract new() => SqlRetryIntervalBaseEnumerator) & (abstract new(timeInterval: TimeSpan, maxTime: TimeSpan, minTime: TimeSpan) => SqlRetryIntervalBaseEnumerator) & {
 };
 
 
 export type SqlRetryIntervalBaseEnumerator = SqlRetryIntervalBaseEnumerator$instance;
 
 export interface SqlRetryLogicBase$instance {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlRetryLogicBase: never;
+
+    readonly __tsonic_iface_System_ICloneable: never;
+
     Current: int;
     NumberOfTries: int;
     RetryIntervalEnumerator: SqlRetryIntervalBaseEnumerator;
-    TransientPredicate: Predicate<Exception>;
+    TransientPredicate: Predicate_1<Exception>;
     Clone(): unknown;
     Reset(): void;
     RetryCondition(sender: unknown): boolean;
@@ -1216,36 +1311,38 @@ export interface SqlRetryLogicBase$instance {
 }
 
 
-export const SqlRetryLogicBase: {
-    new(): SqlRetryLogicBase;
+export const SqlRetryLogicBase: (abstract new() => SqlRetryLogicBase) & {
 };
 
 
 export type SqlRetryLogicBase = SqlRetryLogicBase$instance;
 
 export interface SqlRetryLogicBaseProvider$instance {
-    Retrying: EventHandler<SqlRetryingEventArgs>;
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlRetryLogicBaseProvider: never;
+
+    Retrying: EventHandler_1<SqlRetryingEventArgs>;
     RetryLogic: SqlRetryLogicBase;
-    Execute<TResult>(sender: unknown, function_: Func<TResult>): TResult;
-    ExecuteAsync(sender: unknown, function_: Func<Task>, cancellationToken?: CancellationToken): Task;
-    ExecuteAsync<TResult>(sender: unknown, function_: Func<Task<TResult>>, cancellationToken?: CancellationToken): Task<TResult>;
+    Execute<TResult>(sender: unknown, function_: Func_1<TResult>): TResult;
+    ExecuteAsync(sender: unknown, function_: Func_1<Task>, cancellationToken?: CancellationToken): Task;
+    ExecuteAsync<TResult>(sender: unknown, function_: Func_1<Task_1<TResult>>, cancellationToken?: CancellationToken): Task_1<TResult>;
 }
 
 
-export const SqlRetryLogicBaseProvider: {
-    new(): SqlRetryLogicBaseProvider;
+export const SqlRetryLogicBaseProvider: (abstract new() => SqlRetryLogicBaseProvider) & {
 };
 
 
 export type SqlRetryLogicBaseProvider = SqlRetryLogicBaseProvider$instance;
 
 export interface SqlRetryLogicOption$instance {
-    AuthorizedSqlCondition: Predicate<System_Internal.String>;
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlRetryLogicOption: never;
+
+    AuthorizedSqlCondition: Predicate_1<System_Internal.String>;
     DeltaTime: TimeSpan;
     MaxTimeInterval: TimeSpan;
     MinTimeInterval: TimeSpan;
     NumberOfTries: int;
-    TransientErrors: IEnumerable__System_Collections_Generic<System_Internal.Int32>;
+    TransientErrors: IEnumerable_1<System_Internal.Int32>;
 }
 
 
@@ -1257,6 +1354,8 @@ export const SqlRetryLogicOption: {
 export type SqlRetryLogicOption = SqlRetryLogicOption$instance;
 
 export interface SqlRowsCopiedEventArgs$instance extends EventArgs {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlRowsCopiedEventArgs: never;
+
     Abort: boolean;
     readonly RowsCopied: long;
 }
@@ -1270,6 +1369,8 @@ export const SqlRowsCopiedEventArgs: {
 export type SqlRowsCopiedEventArgs = SqlRowsCopiedEventArgs$instance;
 
 export interface SqlRowUpdatedEventArgs$instance extends RowUpdatedEventArgs {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlRowUpdatedEventArgs: never;
+
     readonly Command: SqlCommand;
 }
 
@@ -1281,12 +1382,10 @@ export const SqlRowUpdatedEventArgs: {
 
 export type SqlRowUpdatedEventArgs = SqlRowUpdatedEventArgs$instance;
 
-export abstract class SqlRowUpdatingEventArgs$protected {
-    protected BaseCommand: IDbCommand;
-}
-
+export interface SqlRowUpdatingEventArgs$instance extends RowUpdatingEventArgs {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlRowUpdatingEventArgs: never;
 
-export interface SqlRowUpdatingEventArgs$instance extends SqlRowUpdatingEventArgs$protected, RowUpdatingEventArgs {
+    BaseCommand: IDbCommand;
     Command: SqlCommand;
 }
 
@@ -1298,16 +1397,18 @@ export const SqlRowUpdatingEventArgs: {
 
 export type SqlRowUpdatingEventArgs = SqlRowUpdatingEventArgs$instance;
 
-export abstract class SqlTransaction$protected {
-    protected readonly DbConnection: DbConnection;
-    protected Dispose(disposing: boolean): void;
-}
+export interface SqlTransaction$instance extends DbTransaction {
+    readonly __tsonic_type_Microsoft_Data_SqlClient_SqlTransaction: never;
 
+    readonly __tsonic_iface_System_Data_IDbTransaction: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqlTransaction$instance extends SqlTransaction$protected, DbTransaction {
     readonly Connection: SqlConnection;
+    readonly DbConnection: DbConnection;
     readonly IsolationLevel: IsolationLevel;
     Commit(): void;
+    Dispose(disposing: boolean): void;
     Rollback(): void;
     Rollback(transactionName: string): void;
     Save(savePointName: string): void;
@@ -1315,7 +1416,6 @@ export interface SqlTransaction$instance extends SqlTransaction$protected, DbTra
 
 
 export const SqlTransaction: {
-    new(): SqlTransaction;
 };