@tsonic/efcore-sqlserver 10.0.1 → 10.0.5

package/Microsoft.IdentityModel.Tokens/internal/index.d.ts

@@ -20,7 +20,7 @@ import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Ru
 import type { ISerializable, SerializationInfo, StreamingContext } from "@tsonic/dotnet/System.Runtime.Serialization.js";
 import * as System_Security_Claims_Internal from "@tsonic/dotnet/System.Security.Claims.js";
 import type { Claim, ClaimsIdentity, ClaimsPrincipal } from "@tsonic/dotnet/System.Security.Claims.js";
-import type { AsymmetricAlgorithm, ECDsa, HashAlgorithm, HashAlgorithmName, KeyedHashAlgorithm, RSA, RSAParameters } from "@tsonic/dotnet/System.Security.Cryptography.js";
+import type { AsymmetricAlgorithm, ECDsa, HashAlgorithm, HashAlgorithmName, KeyedHashAlgorithm, RSA, RSAParameters, SymmetricAlgorithm } from "@tsonic/dotnet/System.Security.Cryptography.js";
 import type { X509Certificate2 } from "@tsonic/dotnet/System.Security.Cryptography.X509Certificates.js";
 import * as System_Security_Principal_Internal from "@tsonic/dotnet/System.Security.Principal.js";
 import type { IIdentity } from "@tsonic/dotnet/System.Security.Principal.js";
@@ -91,6 +91,8 @@ export type TypeValidator = (type: string, securityToken: SecurityToken, validat
 
 
 export interface ICompressionProvider$instance {
+    readonly __tsonic_iface_Microsoft_IdentityModel_Tokens_ICompressionProvider: never;
+
     readonly Algorithm: string;
     Decompress(value: byte[]): byte[];
     IsSupportedAlgorithm(algorithm: string): boolean;
@@ -100,6 +102,8 @@ export interface ICompressionProvider$instance {
 export type ICompressionProvider = ICompressionProvider$instance;
 
 export interface ICryptoProvider$instance {
+    readonly __tsonic_iface_Microsoft_IdentityModel_Tokens_ICryptoProvider: never;
+
     Create(algorithm: string, ...args: unknown[]): unknown;
     IsSupportedAlgorithm(algorithm: string, ...args: unknown[]): boolean;
     Release(cryptoInstance: unknown): void;
@@ -109,6 +113,8 @@ export interface ICryptoProvider$instance {
 export type ICryptoProvider = ICryptoProvider$instance;
 
 export interface ISecurityTokenValidator$instance {
+    readonly __tsonic_iface_Microsoft_IdentityModel_Tokens_ISecurityTokenValidator: never;
+
     readonly CanValidateToken: boolean;
     MaximumTokenSizeInBytes: int;
     CanReadToken(securityToken: string): boolean;
@@ -119,6 +125,8 @@ export interface ISecurityTokenValidator$instance {
 export type ISecurityTokenValidator = ISecurityTokenValidator$instance;
 
 export interface ITokenReplayCache$instance {
+    readonly __tsonic_iface_Microsoft_IdentityModel_Tokens_ITokenReplayCache: never;
+
     TryAdd(securityToken: string, expiresOn: DateTime): boolean;
     TryFind(securityToken: string): boolean;
 }
@@ -132,16 +140,20 @@ export interface AsymmetricSecurityKey$instance extends SecurityKey {
 }
 
 
-export const AsymmetricSecurityKey: {
-    new(): AsymmetricSecurityKey;
+export const AsymmetricSecurityKey: (abstract new() => AsymmetricSecurityKey) & {
 };
 
 
 export type AsymmetricSecurityKey = AsymmetricSecurityKey$instance;
 
 export interface AsymmetricSignatureProvider$instance extends SignatureProvider {
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly MinimumAsymmetricKeySizeInBitsForSigningMap: IReadOnlyDictionary<System_Internal.String, System_Internal.Int32>;
     readonly MinimumAsymmetricKeySizeInBitsForVerifyingMap: IReadOnlyDictionary<System_Internal.String, System_Internal.Int32>;
+    Dispose(disposing: boolean): void;
+    Dispose(): void;
+    GetHashAlgorithmName(algorithm: string): HashAlgorithmName;
     Sign(input: ReadOnlySpan<System_Internal.Byte>, signature: Span<System_Internal.Byte>, bytesWritten: int): boolean;
     Sign(input: byte[]): byte[];
     Sign(input: byte[], offset: int, count: int): byte[];
@@ -163,13 +175,19 @@ export const AsymmetricSignatureProvider: {
 export type AsymmetricSignatureProvider = AsymmetricSignatureProvider$instance;
 
 export interface AuthenticatedEncryptionProvider$instance {
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly Algorithm: string;
     Context: string;
     readonly Key: SecurityKey;
     Decrypt(ciphertext: byte[], authenticatedData: byte[], iv: byte[], authenticationTag: byte[]): byte[];
     Dispose(): void;
+    Dispose(disposing: boolean): void;
     Encrypt(plaintext: byte[], authenticatedData: byte[]): AuthenticatedEncryptionResult;
     Encrypt(plaintext: byte[], authenticatedData: byte[], iv: byte[]): AuthenticatedEncryptionResult;
+    GetKeyBytes(key: SecurityKey): byte[];
+    IsSupportedAlgorithm(key: SecurityKey, algorithm: string): boolean;
+    ValidateKeySize(key: SecurityKey, algorithm: string): void;
 }
 
 
@@ -181,10 +199,10 @@ export const AuthenticatedEncryptionProvider: {
 export type AuthenticatedEncryptionProvider = AuthenticatedEncryptionProvider$instance;
 
 export interface AuthenticatedEncryptionResult$instance {
-    readonly AuthenticationTag: byte[];
-    readonly Ciphertext: byte[];
-    readonly IV: byte[];
-    readonly Key: SecurityKey;
+    AuthenticationTag: byte[];
+    Ciphertext: byte[];
+    IV: byte[];
+    Key: SecurityKey;
 }
 
 
@@ -204,7 +222,7 @@ export interface BaseConfiguration$instance {
 }
 
 
-export const BaseConfiguration: {
+export const BaseConfiguration: (abstract new() => BaseConfiguration) & {
 };
 
 
@@ -223,9 +241,7 @@ export interface BaseConfigurationManager$instance {
 }
 
 
-export const BaseConfigurationManager: {
-    new(): BaseConfigurationManager;
-    new(options: LKGConfigurationCacheOptions): BaseConfigurationManager;
+export const BaseConfigurationManager: (abstract new() => BaseConfigurationManager) & (abstract new(options: LKGConfigurationCacheOptions) => BaseConfigurationManager) & {
     readonly DefaultAutomaticRefreshInterval: TimeSpan;
     readonly DefaultLastKnownGoodConfigurationLifetime: TimeSpan;
     readonly DefaultRefreshInterval: TimeSpan;
@@ -249,7 +265,9 @@ export const CallContext: {
 export type CallContext = CallContext$instance;
 
 export interface CaseSensitiveClaimsIdentity$instance extends ClaimsIdentity {
-    readonly SecurityToken: SecurityToken;
+    readonly __tsonic_iface_System_Security_Principal_IIdentity: never;
+
+    SecurityToken: SecurityToken;
     FindAll(type: string): IEnumerable<Claim>;
     FindFirst(type: string): Claim;
     HasClaim(type: string, value: string): boolean;
@@ -299,13 +317,15 @@ export const CompressionProviderFactory: {
 export type CompressionProviderFactory = CompressionProviderFactory$instance;
 
 export interface CryptoProviderCache$instance {
+    GetCacheKey(signatureProvider: SignatureProvider): string;
+    GetCacheKey(securityKey: SecurityKey, algorithm: string, typeofProvider: string): string;
     TryAdd(signatureProvider: SignatureProvider): boolean;
     TryGetSignatureProvider(securityKey: SecurityKey, algorithm: string, typeofProvider: string, willCreateSignatures: boolean, signatureProvider: SignatureProvider): boolean;
     TryRemove(signatureProvider: SignatureProvider): boolean;
 }
 
 
-export const CryptoProviderCache: {
+export const CryptoProviderCache: (abstract new() => CryptoProviderCache) & {
 };
 
 
@@ -326,7 +346,7 @@ export type CryptoProviderCacheOptions = CryptoProviderCacheOptions$instance;
 
 export interface CryptoProviderFactory$instance {
     CacheSignatureProviders: boolean;
-    readonly CryptoProviderCache: CryptoProviderCache;
+    CryptoProviderCache: CryptoProviderCache;
     CustomCryptoProvider: ICryptoProvider;
     SignatureProviderObjectPoolCacheSize: int;
     CreateAuthenticatedEncryptionProvider(key: SecurityKey, algorithm: string): AuthenticatedEncryptionProvider;
@@ -361,8 +381,10 @@ export const CryptoProviderFactory: {
 export type CryptoProviderFactory = CryptoProviderFactory$instance;
 
 export interface DeflateCompressionProvider$instance {
+    readonly __tsonic_iface_Microsoft_IdentityModel_Tokens_ICompressionProvider: never;
+
     readonly Algorithm: string;
-    readonly CompressionLevel: CompressionLevel;
+    CompressionLevel: CompressionLevel;
     MaximumDeflateSize: int;
     Compress(value: byte[]): byte[];
     Decompress(value: byte[]): byte[];
@@ -399,7 +421,7 @@ export const EcdhKeyExchangeProvider: {
 export type EcdhKeyExchangeProvider = EcdhKeyExchangeProvider$instance;
 
 export interface ECDsaSecurityKey$instance extends AsymmetricSecurityKey {
-    readonly ECDsa: ECDsa;
+    ECDsa: ECDsa;
     readonly HasPrivateKey: boolean;
     readonly KeySize: int;
     readonly PrivateKeyStatus: PrivateKeyStatus;
@@ -416,10 +438,10 @@ export const ECDsaSecurityKey: {
 export type ECDsaSecurityKey = ECDsaSecurityKey$instance;
 
 export interface EncryptingCredentials$instance {
-    readonly Alg: string;
+    Alg: string;
     CryptoProviderFactory: CryptoProviderFactory;
-    readonly Enc: string;
-    readonly Key: SecurityKey;
+    Enc: string;
+    Key: SecurityKey;
     KeyExchangePublicKey: SecurityKey;
     SetDefaultCtyClaim: boolean;
 }
@@ -434,7 +456,12 @@ export const EncryptingCredentials: {
 export type EncryptingCredentials = EncryptingCredentials$instance;
 
 export interface InMemoryCryptoProviderCache$instance extends CryptoProviderCache {
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(): void;
+    Dispose(disposing: boolean): void;
+    GetCacheKey(signatureProvider: SignatureProvider): string;
+    GetCacheKey(securityKey: SecurityKey, algorithm: string, typeofProvider: string): string;
     TryAdd(signatureProvider: SignatureProvider): boolean;
     TryGetSignatureProvider(securityKey: SecurityKey, algorithm: string, typeofProvider: string, willCreateSignatures: boolean, signatureProvider: SignatureProvider): boolean;
     TryRemove(signatureProvider: SignatureProvider): boolean;
@@ -478,7 +505,7 @@ export interface JsonWebKey$instance extends SecurityKey {
     Y: string;
     CanComputeJwkThumbprint(): boolean;
     ComputeJwkThumbprint(): byte[];
-    ToString(): string | undefined;
+    ToString(): string;
 }
 
 
@@ -510,7 +537,7 @@ export type JsonWebKeyConverter = JsonWebKeyConverter$instance;
 
 export interface JsonWebKeySet$instance {
     readonly AdditionalData: IDictionary<System_Internal.String, unknown>;
-    readonly Keys: IList<JsonWebKey>;
+    Keys: IList<JsonWebKey>;
     SkipUnresolvedJsonWebKeys: boolean;
     GetSigningKeys(): IList<SecurityKey>;
 }
@@ -527,25 +554,33 @@ export const JsonWebKeySet: {
 export type JsonWebKeySet = JsonWebKeySet$instance;
 
 export interface KeyWrapProvider$instance {
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly Algorithm: string;
     Context: string;
     readonly Key: SecurityKey;
     Dispose(): void;
+    Dispose(disposing: boolean): void;
     UnwrapKey(keyBytes: byte[]): byte[];
     WrapKey(keyBytes: byte[]): byte[];
 }
 
 
-export const KeyWrapProvider: {
+export const KeyWrapProvider: (abstract new() => KeyWrapProvider) & {
 };
 
 
 export type KeyWrapProvider = KeyWrapProvider$instance;
 
 export interface RsaKeyWrapProvider$instance extends KeyWrapProvider {
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly Algorithm: string;
     Context: string;
     readonly Key: SecurityKey;
+    Dispose(disposing: boolean): void;
+    Dispose(): void;
+    IsSupportedAlgorithm(key: SecurityKey, algorithm: string): boolean;
     UnwrapKey(keyBytes: byte[]): byte[];
     WrapKey(keyBytes: byte[]): byte[];
 }
@@ -561,9 +596,9 @@ export type RsaKeyWrapProvider = RsaKeyWrapProvider$instance;
 export interface RsaSecurityKey$instance extends AsymmetricSecurityKey {
     readonly HasPrivateKey: boolean;
     readonly KeySize: int;
-    readonly Parameters: RSAParameters;
+    Parameters: RSAParameters;
     readonly PrivateKeyStatus: PrivateKeyStatus;
-    readonly Rsa: RSA;
+    Rsa: RSA;
     CanComputeJwkThumbprint(): boolean;
     ComputeJwkThumbprint(): byte[];
 }
@@ -584,12 +619,11 @@ export interface SecurityKey$instance {
     CanComputeJwkThumbprint(): boolean;
     ComputeJwkThumbprint(): byte[];
     IsSupportedAlgorithm(algorithm: string): boolean;
-    ToString(): string | undefined;
+    ToString(): string;
 }
 
 
-export const SecurityKey: {
-    new(): SecurityKey;
+export const SecurityKey: (abstract new() => SecurityKey) & {
 };
 
 
@@ -607,6 +641,8 @@ export const SecurityKeyIdentifierClause: {
 export type SecurityKeyIdentifierClause = SecurityKeyIdentifierClause$instance;
 
 export interface SecurityToken$instance {
+    readonly __tsonic_iface_Microsoft_IdentityModel_Logging_ISafeLogSecurityArtifact: never;
+
     readonly Id: string;
     readonly Issuer: string;
     readonly SecurityKey: SecurityKey;
@@ -617,7 +653,7 @@ export interface SecurityToken$instance {
 }
 
 
-export const SecurityToken: {
+export const SecurityToken: (abstract new() => SecurityToken) & {
 };
 
 
@@ -631,6 +667,8 @@ export type SecurityToken = SecurityToken$instance & __SecurityToken$views;
 
 
 export interface SecurityTokenArgumentException$instance extends ArgumentException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -644,6 +682,8 @@ export const SecurityTokenArgumentException: {
 export type SecurityTokenArgumentException = SecurityTokenArgumentException$instance;
 
 export interface SecurityTokenCompressionFailedException$instance extends SecurityTokenException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -657,6 +697,8 @@ export const SecurityTokenCompressionFailedException: {
 export type SecurityTokenCompressionFailedException = SecurityTokenCompressionFailedException$instance;
 
 export interface SecurityTokenDecompressionFailedException$instance extends SecurityTokenException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -670,6 +712,8 @@ export const SecurityTokenDecompressionFailedException: {
 export type SecurityTokenDecompressionFailedException = SecurityTokenDecompressionFailedException$instance;
 
 export interface SecurityTokenDecryptionFailedException$instance extends SecurityTokenException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -694,8 +738,7 @@ export interface SecurityTokenDescriptor$instance {
     Issuer: string;
     NotBefore: Nullable<DateTime>;
     SigningCredentials: SigningCredentials;
-    get Subject(): ClaimsIdentity | undefined;
-    set Subject(value: ClaimsIdentity);
+    Subject: ClaimsIdentity;
     TokenType: string;
 }
 
@@ -708,6 +751,8 @@ export const SecurityTokenDescriptor: {
 export type SecurityTokenDescriptor = SecurityTokenDescriptor$instance;
 
 export interface SecurityTokenEncryptionFailedException$instance extends SecurityTokenException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -721,6 +766,8 @@ export const SecurityTokenEncryptionFailedException: {
 export type SecurityTokenEncryptionFailedException = SecurityTokenEncryptionFailedException$instance;
 
 export interface SecurityTokenEncryptionKeyNotFoundException$instance extends SecurityTokenDecryptionFailedException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -734,6 +781,8 @@ export const SecurityTokenEncryptionKeyNotFoundException: {
 export type SecurityTokenEncryptionKeyNotFoundException = SecurityTokenEncryptionKeyNotFoundException$instance;
 
 export interface SecurityTokenException$instance extends Exception {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -748,6 +797,8 @@ export const SecurityTokenException: {
 export type SecurityTokenException = SecurityTokenException$instance;
 
 export interface SecurityTokenExpiredException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     Expires: DateTime;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -763,6 +814,8 @@ export const SecurityTokenExpiredException: {
 export type SecurityTokenExpiredException = SecurityTokenExpiredException$instance;
 
 export interface SecurityTokenHandler$instance extends TokenHandler {
+    readonly __tsonic_iface_Microsoft_IdentityModel_Tokens_ISecurityTokenValidator: never;
+
     readonly CanValidateToken: boolean;
     readonly CanWriteToken: boolean;
     readonly TokenType: Type;
@@ -778,7 +831,7 @@ export interface SecurityTokenHandler$instance extends TokenHandler {
 }
 
 
-export const SecurityTokenHandler: {
+export const SecurityTokenHandler: (abstract new() => SecurityTokenHandler) & {
 };
 
 
@@ -792,6 +845,8 @@ export type SecurityTokenHandler = SecurityTokenHandler$instance & __SecurityTok
 
 
 export interface SecurityTokenInvalidAlgorithmException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     InvalidAlgorithm: string;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -807,6 +862,8 @@ export const SecurityTokenInvalidAlgorithmException: {
 export type SecurityTokenInvalidAlgorithmException = SecurityTokenInvalidAlgorithmException$instance;
 
 export interface SecurityTokenInvalidAudienceException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     InvalidAudience: string;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -822,6 +879,8 @@ export const SecurityTokenInvalidAudienceException: {
 export type SecurityTokenInvalidAudienceException = SecurityTokenInvalidAudienceException$instance;
 
 export interface SecurityTokenInvalidIssuerException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     InvalidIssuer: string;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -837,6 +896,8 @@ export const SecurityTokenInvalidIssuerException: {
 export type SecurityTokenInvalidIssuerException = SecurityTokenInvalidIssuerException$instance;
 
 export interface SecurityTokenInvalidLifetimeException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     Expires: Nullable<DateTime>;
     NotBefore: Nullable<DateTime>;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
@@ -853,6 +914,8 @@ export const SecurityTokenInvalidLifetimeException: {
 export type SecurityTokenInvalidLifetimeException = SecurityTokenInvalidLifetimeException$instance;
 
 export interface SecurityTokenInvalidSignatureException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -866,6 +929,8 @@ export const SecurityTokenInvalidSignatureException: {
 export type SecurityTokenInvalidSignatureException = SecurityTokenInvalidSignatureException$instance;
 
 export interface SecurityTokenInvalidSigningKeyException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     SigningKey: SecurityKey;
 }
 
@@ -880,6 +945,8 @@ export const SecurityTokenInvalidSigningKeyException: {
 export type SecurityTokenInvalidSigningKeyException = SecurityTokenInvalidSigningKeyException$instance;
 
 export interface SecurityTokenInvalidTypeException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     InvalidType: string;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -895,6 +962,8 @@ export const SecurityTokenInvalidTypeException: {
 export type SecurityTokenInvalidTypeException = SecurityTokenInvalidTypeException$instance;
 
 export interface SecurityTokenKeyWrapException$instance extends SecurityTokenException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -908,6 +977,8 @@ export const SecurityTokenKeyWrapException: {
 export type SecurityTokenKeyWrapException = SecurityTokenKeyWrapException$instance;
 
 export interface SecurityTokenMalformedException$instance extends SecurityTokenArgumentException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -921,6 +992,8 @@ export const SecurityTokenMalformedException: {
 export type SecurityTokenMalformedException = SecurityTokenMalformedException$instance;
 
 export interface SecurityTokenNoExpirationException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -934,6 +1007,8 @@ export const SecurityTokenNoExpirationException: {
 export type SecurityTokenNoExpirationException = SecurityTokenNoExpirationException$instance;
 
 export interface SecurityTokenNotYetValidException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     NotBefore: DateTime;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -949,6 +1024,8 @@ export const SecurityTokenNotYetValidException: {
 export type SecurityTokenNotYetValidException = SecurityTokenNotYetValidException$instance;
 
 export interface SecurityTokenReplayAddFailedException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -962,6 +1039,8 @@ export const SecurityTokenReplayAddFailedException: {
 export type SecurityTokenReplayAddFailedException = SecurityTokenReplayAddFailedException$instance;
 
 export interface SecurityTokenReplayDetectedException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -975,6 +1054,8 @@ export const SecurityTokenReplayDetectedException: {
 export type SecurityTokenReplayDetectedException = SecurityTokenReplayDetectedException$instance;
 
 export interface SecurityTokenSignatureKeyNotFoundException$instance extends SecurityTokenInvalidSignatureException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -988,6 +1069,8 @@ export const SecurityTokenSignatureKeyNotFoundException: {
 export type SecurityTokenSignatureKeyNotFoundException = SecurityTokenSignatureKeyNotFoundException$instance;
 
 export interface SecurityTokenUnableToValidateException$instance extends SecurityTokenInvalidSignatureException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     ValidationFailure: ValidationFailure;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -1004,6 +1087,8 @@ export const SecurityTokenUnableToValidateException: {
 export type SecurityTokenUnableToValidateException = SecurityTokenUnableToValidateException$instance;
 
 export interface SecurityTokenValidationException$instance extends SecurityTokenException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -1017,12 +1102,15 @@ export const SecurityTokenValidationException: {
 export type SecurityTokenValidationException = SecurityTokenValidationException$instance;
 
 export interface SignatureProvider$instance {
-    readonly Algorithm: string;
+    readonly __tsonic_iface_System_IDisposable: never;
+
+    Algorithm: string;
     Context: string;
     CryptoProviderCache: CryptoProviderCache;
-    readonly Key: SecurityKey;
-    readonly WillCreateSignatures: boolean;
+    Key: SecurityKey;
+    WillCreateSignatures: boolean;
     Dispose(): void;
+    Dispose(disposing: boolean): void;
     Sign(input: byte[]): byte[];
     Sign(input: byte[], offset: int, count: int): byte[];
     Sign(data: ReadOnlySpan<System_Internal.Byte>, destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
@@ -1031,17 +1119,17 @@ export interface SignatureProvider$instance {
 }
 
 
-export const SignatureProvider: {
+export const SignatureProvider: (abstract new(key: SecurityKey, algorithm: string) => SignatureProvider) & {
 };
 
 
 export type SignatureProvider = SignatureProvider$instance;
 
 export interface SigningCredentials$instance {
-    readonly Algorithm: string;
+    Algorithm: string;
     CryptoProviderFactory: CryptoProviderFactory;
-    readonly Digest: string;
-    readonly Key: SecurityKey;
+    Digest: string;
+    Key: SecurityKey;
     readonly Kid: string;
 }
 
@@ -1055,9 +1143,15 @@ export const SigningCredentials: {
 export type SigningCredentials = SigningCredentials$instance;
 
 export interface SymmetricKeyWrapProvider$instance extends KeyWrapProvider {
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly Algorithm: string;
     Context: string;
     readonly Key: SecurityKey;
+    Dispose(disposing: boolean): void;
+    Dispose(): void;
+    GetSymmetricAlgorithm(key: SecurityKey, algorithm: string): SymmetricAlgorithm;
+    IsSupportedAlgorithm(key: SecurityKey, algorithm: string): boolean;
     UnwrapKey(keyBytes: byte[]): byte[];
     WrapKey(keyBytes: byte[]): byte[];
 }
@@ -1086,7 +1180,14 @@ export const SymmetricSecurityKey: {
 export type SymmetricSecurityKey = SymmetricSecurityKey$instance;
 
 export interface SymmetricSignatureProvider$instance extends SignatureProvider {
+    readonly __tsonic_iface_System_IDisposable: never;
+
     MinimumSymmetricKeySizeInBits: int;
+    Dispose(disposing: boolean): void;
+    Dispose(): void;
+    GetKeyBytes(key: SecurityKey): byte[];
+    GetKeyedHashAlgorithm(keyBytes: byte[], algorithm: string): KeyedHashAlgorithm;
+    ReleaseKeyedHashAlgorithm(keyedHashAlgorithm: KeyedHashAlgorithm): void;
     Sign(input: byte[]): byte[];
     Sign(input: ReadOnlySpan<System_Internal.Byte>, signature: Span<System_Internal.Byte>, bytesWritten: int): boolean;
     Sign(input: byte[], offset: int, count: int): byte[];
@@ -1128,7 +1229,7 @@ export interface TokenHandler$instance {
 }
 
 
-export const TokenHandler: {
+export const TokenHandler: (abstract new() => TokenHandler) & {
     readonly DefaultTokenLifetimeInMinutes: int;
 };
 
@@ -1147,7 +1248,7 @@ export interface TokenValidationParameters$instance {
     IgnoreTrailingSlashWhenValidatingAudience: boolean;
     IncludeTokenOnFailedValidation: boolean;
     readonly InstancePropertyBag: IDictionary<System_Internal.String, unknown>;
-    readonly IsClone: boolean;
+    IsClone: boolean;
     IssuerSigningKey: SecurityKey;
     IssuerSigningKeyResolver: IssuerSigningKeyResolver;
     IssuerSigningKeyResolverUsingConfiguration: IssuerSigningKeyResolverUsingConfiguration;
@@ -1218,7 +1319,7 @@ export interface TokenValidationResult$instance {
     readonly PropertyBag: IDictionary<System_Internal.String, unknown>;
     SecurityToken: SecurityToken;
     TokenContext: CallContext;
-    readonly TokenOnFailedValidation: SecurityToken;
+    TokenOnFailedValidation: SecurityToken;
     TokenType: string;
 }
 
@@ -1231,7 +1332,7 @@ export const TokenValidationResult: {
 export type TokenValidationResult = TokenValidationResult$instance;
 
 export interface X509EncryptingCredentials$instance extends EncryptingCredentials {
-    readonly Certificate: X509Certificate2 | undefined;
+    Certificate: X509Certificate2;
 }
 
 
@@ -1244,7 +1345,7 @@ export const X509EncryptingCredentials: {
 export type X509EncryptingCredentials = X509EncryptingCredentials$instance;
 
 export interface X509SecurityKey$instance extends AsymmetricSecurityKey {
-    readonly Certificate: X509Certificate2 | undefined;
+    Certificate: X509Certificate2;
     readonly HasPrivateKey: boolean;
     readonly KeySize: int;
     readonly PrivateKey: AsymmetricAlgorithm;
@@ -1267,7 +1368,7 @@ export const X509SecurityKey: {
 export type X509SecurityKey = X509SecurityKey$instance;
 
 export interface X509SigningCredentials$instance extends SigningCredentials {
-    readonly Certificate: X509Certificate2 | undefined;
+    Certificate: X509Certificate2;
 }