@tsonic/efcore-sqlserver 10.0.5 → 10.0.7

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

@@ -12,21 +12,21 @@ import type { ptr } from "@tsonic/core/types.js";
 import * as Microsoft_IdentityModel_Logging_Internal from "../../Microsoft.IdentityModel.Logging/internal/index.js";
 import type { ISafeLogSecurityArtifact, LoggerContext } from "../../Microsoft.IdentityModel.Logging/internal/index.js";
 import type { LKGConfigurationCacheOptions } from "../../Microsoft.IdentityModel.Tokens.Configuration/internal/index.js";
-import type { Dictionary, ICollection, IDictionary, IEnumerable, IList, IReadOnlyDictionary } from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { CompressionLevel } from "@tsonic/dotnet/System.IO.Compression.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { ArgumentException, AsyncCallback, Boolean as ClrBoolean, Byte, Char, DateTime, DateTimeKind, Enum, Exception, Func, Guid, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormattable, Int32, Int64, IntPtr, ISpanFormattable, MulticastDelegate, Nullable, Object as ClrObject, ReadOnlySpan, Span, String as ClrString, TimeSpan, Type, Uri, 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 * 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, 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";
-import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
-import type { Task } from "@tsonic/dotnet/System.Threading.Tasks.js";
-import type { XmlReader, XmlWriter } from "@tsonic/dotnet/System.Xml.js";
+import type { Dictionary_2, ICollection_1, IDictionary_2, IEnumerable_1, IList_1, IReadOnlyDictionary_2 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { CompressionLevel } from "@tsonic/dotnet/System.IO.Compression/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 * as System_Security_Claims_Internal from "@tsonic/dotnet/System.Security.Claims/internal/index.js";
+import type { Claim, ClaimsIdentity, ClaimsPrincipal } from "@tsonic/dotnet/System.Security.Claims/internal/index.js";
+import type { X509Certificate2 } from "@tsonic/dotnet/System.Security.Cryptography.X509Certificates/internal/index.js";
+import type { AsymmetricAlgorithm, ECDsa, HashAlgorithm, HashAlgorithmName, KeyedHashAlgorithm, RSA, RSAParameters, SymmetricAlgorithm } from "@tsonic/dotnet/System.Security.Cryptography/internal/index.js";
+import * as System_Security_Principal_Internal from "@tsonic/dotnet/System.Security.Principal/internal/index.js";
+import type { IIdentity } from "@tsonic/dotnet/System.Security.Principal/internal/index.js";
+import type { 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, XmlWriter } from "@tsonic/dotnet/System.Xml/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { ArgumentException, AsyncCallback, Boolean as ClrBoolean, Byte, Char, DateTime, DateTimeKind, Enum, Exception, Func_3, Guid, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormattable, Int32, Int64, IntPtr, ISpanFormattable, MulticastDelegate, Nullable_1, Object as ClrObject, ReadOnlySpan_1, Span_1, String as ClrString, TimeSpan, Type, Uri, Void } from "@tsonic/dotnet/System/internal/index.js";
 
 export enum PrivateKeyStatus {
     Exists = 0,
@@ -45,13 +45,13 @@ export enum ValidationFailure {
 export type AlgorithmValidator = (algorithm: string, securityKey: SecurityKey, securityToken: SecurityToken, validationParameters: TokenValidationParameters) => boolean;
 
 
-export type AudienceValidator = (audiences: IEnumerable<System_Internal.String>, securityToken: SecurityToken, validationParameters: TokenValidationParameters) => boolean;
+export type AudienceValidator = (audiences: IEnumerable_1<System_Internal.String>, securityToken: SecurityToken, validationParameters: TokenValidationParameters) => boolean;
 
 
-export type IssuerSigningKeyResolver = (token: string, securityToken: SecurityToken, kid: string, validationParameters: TokenValidationParameters) => IEnumerable<SecurityKey>;
+export type IssuerSigningKeyResolver = (token: string, securityToken: SecurityToken, kid: string, validationParameters: TokenValidationParameters) => IEnumerable_1<SecurityKey>;
 
 
-export type IssuerSigningKeyResolverUsingConfiguration = (token: string, securityToken: SecurityToken, kid: string, validationParameters: TokenValidationParameters, configuration: BaseConfiguration) => IEnumerable<SecurityKey>;
+export type IssuerSigningKeyResolverUsingConfiguration = (token: string, securityToken: SecurityToken, kid: string, validationParameters: TokenValidationParameters, configuration: BaseConfiguration) => IEnumerable_1<SecurityKey>;
 
 
 export type IssuerSigningKeyValidator = (securityKey: SecurityKey, securityToken: SecurityToken, validationParameters: TokenValidationParameters) => boolean;
@@ -66,7 +66,7 @@ export type IssuerValidator = (issuer: string, securityToken: SecurityToken, val
 export type IssuerValidatorUsingConfiguration = (issuer: string, securityToken: SecurityToken, validationParameters: TokenValidationParameters, configuration: BaseConfiguration) => string;
 
 
-export type LifetimeValidator = (notBefore: Nullable<DateTime>, expires: Nullable<DateTime>, securityToken: SecurityToken, validationParameters: TokenValidationParameters) => boolean;
+export type LifetimeValidator = (notBefore: Nullable_1<DateTime>, expires: Nullable_1<DateTime>, securityToken: SecurityToken, validationParameters: TokenValidationParameters) => boolean;
 
 
 export type SignatureValidator = (token: string, validationParameters: TokenValidationParameters) => SecurityToken;
@@ -75,13 +75,13 @@ export type SignatureValidator = (token: string, validationParameters: TokenVali
 export type SignatureValidatorUsingConfiguration = (token: string, validationParameters: TokenValidationParameters, configuration: BaseConfiguration) => SecurityToken;
 
 
-export type TokenDecryptionKeyResolver = (token: string, securityToken: SecurityToken, kid: string, validationParameters: TokenValidationParameters) => IEnumerable<SecurityKey>;
+export type TokenDecryptionKeyResolver = (token: string, securityToken: SecurityToken, kid: string, validationParameters: TokenValidationParameters) => IEnumerable_1<SecurityKey>;
 
 
 export type TokenReader = (token: string, validationParameters: TokenValidationParameters) => SecurityToken;
 
 
-export type TokenReplayValidator = (expirationTime: Nullable<DateTime>, securityToken: string, validationParameters: TokenValidationParameters) => boolean;
+export type TokenReplayValidator = (expirationTime: Nullable_1<DateTime>, securityToken: string, validationParameters: TokenValidationParameters) => boolean;
 
 
 export type TransformBeforeSignatureValidation = (token: SecurityToken, validationParameters: TokenValidationParameters) => SecurityToken;
@@ -135,6 +135,8 @@ export interface ITokenReplayCache$instance {
 export type ITokenReplayCache = ITokenReplayCache$instance;
 
 export interface AsymmetricSecurityKey$instance extends SecurityKey {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_AsymmetricSecurityKey: never;
+
     readonly HasPrivateKey: boolean;
     readonly PrivateKeyStatus: PrivateKeyStatus;
 }
@@ -147,17 +149,19 @@ export const AsymmetricSecurityKey: (abstract new() => AsymmetricSecurityKey) &
 export type AsymmetricSecurityKey = AsymmetricSecurityKey$instance;
 
 export interface AsymmetricSignatureProvider$instance extends SignatureProvider {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_AsymmetricSignatureProvider: never;
+
     readonly __tsonic_iface_System_IDisposable: never;
 
-    readonly MinimumAsymmetricKeySizeInBitsForSigningMap: IReadOnlyDictionary<System_Internal.String, System_Internal.Int32>;
-    readonly MinimumAsymmetricKeySizeInBitsForVerifyingMap: IReadOnlyDictionary<System_Internal.String, System_Internal.Int32>;
+    readonly MinimumAsymmetricKeySizeInBitsForSigningMap: IReadOnlyDictionary_2<System_Internal.String, System_Internal.Int32>;
+    readonly MinimumAsymmetricKeySizeInBitsForVerifyingMap: IReadOnlyDictionary_2<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: ReadOnlySpan_1<System_Internal.Byte>, signature: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
     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;
+    Sign(data: ReadOnlySpan_1<System_Internal.Byte>, destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
     ValidateAsymmetricSecurityKeySize(key: SecurityKey, algorithm: string, willCreateSignatures: boolean): void;
     Verify(input: byte[], signature: byte[]): boolean;
     Verify(input: byte[], inputOffset: int, inputLength: int, signature: byte[], signatureOffset: int, signatureLength: int): boolean;
@@ -167,14 +171,16 @@ export interface AsymmetricSignatureProvider$instance extends SignatureProvider
 export const AsymmetricSignatureProvider: {
     new(key: SecurityKey, algorithm: string): AsymmetricSignatureProvider;
     new(key: SecurityKey, algorithm: string, willCreateSignatures: boolean): AsymmetricSignatureProvider;
-    readonly DefaultMinimumAsymmetricKeySizeInBitsForSigningMap: Dictionary<System_Internal.String, System_Internal.Int32>;
-    readonly DefaultMinimumAsymmetricKeySizeInBitsForVerifyingMap: Dictionary<System_Internal.String, System_Internal.Int32>;
+    readonly DefaultMinimumAsymmetricKeySizeInBitsForSigningMap: Dictionary_2<System_Internal.String, System_Internal.Int32>;
+    readonly DefaultMinimumAsymmetricKeySizeInBitsForVerifyingMap: Dictionary_2<System_Internal.String, System_Internal.Int32>;
 };
 
 
 export type AsymmetricSignatureProvider = AsymmetricSignatureProvider$instance;
 
 export interface AuthenticatedEncryptionProvider$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_AuthenticatedEncryptionProvider: never;
+
     readonly __tsonic_iface_System_IDisposable: never;
 
     readonly Algorithm: string;
@@ -199,6 +205,8 @@ export const AuthenticatedEncryptionProvider: {
 export type AuthenticatedEncryptionProvider = AuthenticatedEncryptionProvider$instance;
 
 export interface AuthenticatedEncryptionResult$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_AuthenticatedEncryptionResult: never;
+
     AuthenticationTag: byte[];
     Ciphertext: byte[];
     IV: byte[];
@@ -214,10 +222,12 @@ export const AuthenticatedEncryptionResult: {
 export type AuthenticatedEncryptionResult = AuthenticatedEncryptionResult$instance;
 
 export interface BaseConfiguration$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_BaseConfiguration: never;
+
     ActiveTokenEndpoint: string;
     Issuer: string;
-    readonly SigningKeys: ICollection<SecurityKey>;
-    readonly TokenDecryptionKeys: ICollection<SecurityKey>;
+    readonly SigningKeys: ICollection_1<SecurityKey>;
+    readonly TokenDecryptionKeys: ICollection_1<SecurityKey>;
     TokenEndpoint: string;
 }
 
@@ -229,6 +239,8 @@ export const BaseConfiguration: (abstract new() => BaseConfiguration) & {
 export type BaseConfiguration = BaseConfiguration$instance;
 
 export interface BaseConfigurationManager$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_BaseConfigurationManager: never;
+
     AutomaticRefreshInterval: TimeSpan;
     readonly IsLastKnownGoodValid: boolean;
     LastKnownGoodConfiguration: BaseConfiguration;
@@ -236,7 +248,7 @@ export interface BaseConfigurationManager$instance {
     MetadataAddress: string;
     RefreshInterval: TimeSpan;
     UseLastKnownGoodConfiguration: boolean;
-    GetBaseConfigurationAsync(cancel: CancellationToken): Task<BaseConfiguration>;
+    GetBaseConfigurationAsync(cancel: CancellationToken): Task_1<BaseConfiguration>;
     RequestRefresh(): void;
 }
 
@@ -253,6 +265,8 @@ export const BaseConfigurationManager: (abstract new() => BaseConfigurationManag
 export type BaseConfigurationManager = BaseConfigurationManager$instance;
 
 export interface CallContext$instance extends LoggerContext {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CallContext: never;
+
 }
 
 
@@ -265,10 +279,12 @@ export const CallContext: {
 export type CallContext = CallContext$instance;
 
 export interface CaseSensitiveClaimsIdentity$instance extends ClaimsIdentity {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CaseSensitiveClaimsIdentity: never;
+
     readonly __tsonic_iface_System_Security_Principal_IIdentity: never;
 
     SecurityToken: SecurityToken;
-    FindAll(type: string): IEnumerable<Claim>;
+    FindAll(type: string): IEnumerable_1<Claim>;
     FindFirst(type: string): Claim;
     HasClaim(type: string, value: string): boolean;
 }
@@ -278,9 +294,9 @@ export const CaseSensitiveClaimsIdentity: {
     new(): CaseSensitiveClaimsIdentity;
     new(authenticationType: string): CaseSensitiveClaimsIdentity;
     new(claimsIdentity: ClaimsIdentity): CaseSensitiveClaimsIdentity;
-    new(claims: IEnumerable<Claim>): CaseSensitiveClaimsIdentity;
-    new(claims: IEnumerable<Claim>, authenticationType: string): CaseSensitiveClaimsIdentity;
-    new(claims: IEnumerable<Claim>, authenticationType: string, nameType: string, roleType: string): CaseSensitiveClaimsIdentity;
+    new(claims: IEnumerable_1<Claim>): CaseSensitiveClaimsIdentity;
+    new(claims: IEnumerable_1<Claim>, authenticationType: string): CaseSensitiveClaimsIdentity;
+    new(claims: IEnumerable_1<Claim>, authenticationType: string, nameType: string, roleType: string): CaseSensitiveClaimsIdentity;
     new(authenticationType: string, nameType: string, roleType: string): CaseSensitiveClaimsIdentity;
 };
 
@@ -288,6 +304,8 @@ export const CaseSensitiveClaimsIdentity: {
 export type CaseSensitiveClaimsIdentity = CaseSensitiveClaimsIdentity$instance;
 
 export interface CompressionAlgorithms$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CompressionAlgorithms: never;
+
 }
 
 
@@ -300,6 +318,8 @@ export const CompressionAlgorithms: {
 export type CompressionAlgorithms = CompressionAlgorithms$instance;
 
 export interface CompressionProviderFactory$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CompressionProviderFactory: never;
+
     CustomCompressionProvider: ICompressionProvider;
     CreateCompressionProvider(algorithm: string): ICompressionProvider;
     CreateCompressionProvider(algorithm: string, maximumDeflateSize: int): ICompressionProvider;
@@ -317,6 +337,8 @@ export const CompressionProviderFactory: {
 export type CompressionProviderFactory = CompressionProviderFactory$instance;
 
 export interface CryptoProviderCache$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CryptoProviderCache: never;
+
     GetCacheKey(signatureProvider: SignatureProvider): string;
     GetCacheKey(securityKey: SecurityKey, algorithm: string, typeofProvider: string): string;
     TryAdd(signatureProvider: SignatureProvider): boolean;
@@ -332,6 +354,8 @@ export const CryptoProviderCache: (abstract new() => CryptoProviderCache) & {
 export type CryptoProviderCache = CryptoProviderCache$instance;
 
 export interface CryptoProviderCacheOptions$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CryptoProviderCacheOptions: never;
+
     SizeLimit: int;
 }
 
@@ -345,6 +369,8 @@ export const CryptoProviderCacheOptions: {
 export type CryptoProviderCacheOptions = CryptoProviderCacheOptions$instance;
 
 export interface CryptoProviderFactory$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CryptoProviderFactory: never;
+
     CacheSignatureProviders: boolean;
     CryptoProviderCache: CryptoProviderCache;
     CustomCryptoProvider: ICryptoProvider;
@@ -380,7 +406,9 @@ export const CryptoProviderFactory: {
 
 export type CryptoProviderFactory = CryptoProviderFactory$instance;
 
-export interface DeflateCompressionProvider$instance {
+export interface DeflateCompressionProvider$instance extends ICompressionProvider$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_DeflateCompressionProvider: never;
+
     readonly __tsonic_iface_Microsoft_IdentityModel_Tokens_ICompressionProvider: never;
 
     readonly Algorithm: string;
@@ -402,12 +430,12 @@ export interface __DeflateCompressionProvider$views {
     As_ICompressionProvider(): ICompressionProvider$instance;
 }
 
-export interface DeflateCompressionProvider$instance extends ICompressionProvider$instance {}
-
 export type DeflateCompressionProvider = DeflateCompressionProvider$instance & __DeflateCompressionProvider$views;
 
 
 export interface EcdhKeyExchangeProvider$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_EcdhKeyExchangeProvider: never;
+
     KeyDataLen: int;
     GenerateKdf(apu?: string, apv?: string): SecurityKey;
 }
@@ -421,6 +449,8 @@ export const EcdhKeyExchangeProvider: {
 export type EcdhKeyExchangeProvider = EcdhKeyExchangeProvider$instance;
 
 export interface ECDsaSecurityKey$instance extends AsymmetricSecurityKey {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_ECDsaSecurityKey: never;
+
     ECDsa: ECDsa;
     readonly HasPrivateKey: boolean;
     readonly KeySize: int;
@@ -438,6 +468,8 @@ export const ECDsaSecurityKey: {
 export type ECDsaSecurityKey = ECDsaSecurityKey$instance;
 
 export interface EncryptingCredentials$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_EncryptingCredentials: never;
+
     Alg: string;
     CryptoProviderFactory: CryptoProviderFactory;
     Enc: string;
@@ -456,6 +488,8 @@ export const EncryptingCredentials: {
 export type EncryptingCredentials = EncryptingCredentials$instance;
 
 export interface InMemoryCryptoProviderCache$instance extends CryptoProviderCache {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_InMemoryCryptoProviderCache: never;
+
     readonly __tsonic_iface_System_IDisposable: never;
 
     Dispose(): void;
@@ -477,7 +511,9 @@ export const InMemoryCryptoProviderCache: {
 export type InMemoryCryptoProviderCache = InMemoryCryptoProviderCache$instance;
 
 export interface JsonWebKey$instance extends SecurityKey {
-    readonly AdditionalData: IDictionary<System_Internal.String, unknown>;
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_JsonWebKey: never;
+
+    readonly AdditionalData: IDictionary_2<System_Internal.String, unknown>;
     Alg: string;
     Crv: string;
     D: string;
@@ -487,18 +523,18 @@ export interface JsonWebKey$instance extends SecurityKey {
     readonly HasPrivateKey: boolean;
     K: string;
     KeyId: string;
-    readonly KeyOps: IList<System_Internal.String>;
+    readonly KeyOps: IList_1<System_Internal.String>;
     readonly KeySize: int;
     Kid: string;
     Kty: string;
     N: string;
-    readonly Oth: IList<System_Internal.String>;
+    readonly Oth: IList_1<System_Internal.String>;
     P: string;
     Q: string;
     QI: string;
     Use: string;
     X: string;
-    readonly X5c: IList<System_Internal.String>;
+    readonly X5c: IList_1<System_Internal.String>;
     X5t: string;
     X5tS256: string;
     X5u: string;
@@ -519,6 +555,8 @@ export const JsonWebKey: {
 export type JsonWebKey = JsonWebKey$instance;
 
 export interface JsonWebKeyConverter$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_JsonWebKeyConverter: never;
+
 }
 
 
@@ -536,10 +574,12 @@ export const JsonWebKeyConverter: {
 export type JsonWebKeyConverter = JsonWebKeyConverter$instance;
 
 export interface JsonWebKeySet$instance {
-    readonly AdditionalData: IDictionary<System_Internal.String, unknown>;
-    Keys: IList<JsonWebKey>;
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_JsonWebKeySet: never;
+
+    readonly AdditionalData: IDictionary_2<System_Internal.String, unknown>;
+    Keys: IList_1<JsonWebKey>;
     SkipUnresolvedJsonWebKeys: boolean;
-    GetSigningKeys(): IList<SecurityKey>;
+    GetSigningKeys(): IList_1<SecurityKey>;
 }
 
 
@@ -554,6 +594,8 @@ export const JsonWebKeySet: {
 export type JsonWebKeySet = JsonWebKeySet$instance;
 
 export interface KeyWrapProvider$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_KeyWrapProvider: never;
+
     readonly __tsonic_iface_System_IDisposable: never;
 
     readonly Algorithm: string;
@@ -573,6 +615,8 @@ export const KeyWrapProvider: (abstract new() => KeyWrapProvider) & {
 export type KeyWrapProvider = KeyWrapProvider$instance;
 
 export interface RsaKeyWrapProvider$instance extends KeyWrapProvider {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_RsaKeyWrapProvider: never;
+
     readonly __tsonic_iface_System_IDisposable: never;
 
     readonly Algorithm: string;
@@ -594,6 +638,8 @@ export const RsaKeyWrapProvider: {
 export type RsaKeyWrapProvider = RsaKeyWrapProvider$instance;
 
 export interface RsaSecurityKey$instance extends AsymmetricSecurityKey {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_RsaSecurityKey: never;
+
     readonly HasPrivateKey: boolean;
     readonly KeySize: int;
     Parameters: RSAParameters;
@@ -613,6 +659,8 @@ export const RsaSecurityKey: {
 export type RsaSecurityKey = RsaSecurityKey$instance;
 
 export interface SecurityKey$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityKey: never;
+
     CryptoProviderFactory: CryptoProviderFactory;
     KeyId: string;
     readonly KeySize: int;
@@ -630,6 +678,8 @@ export const SecurityKey: (abstract new() => SecurityKey) & {
 export type SecurityKey = SecurityKey$instance;
 
 export interface SecurityKeyIdentifierClause$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityKeyIdentifierClause: never;
+
 }
 
 
@@ -640,7 +690,9 @@ export const SecurityKeyIdentifierClause: {
 
 export type SecurityKeyIdentifierClause = SecurityKeyIdentifierClause$instance;
 
-export interface SecurityToken$instance {
+export interface SecurityToken$instance extends Microsoft_IdentityModel_Logging_Internal.ISafeLogSecurityArtifact$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityToken: never;
+
     readonly __tsonic_iface_Microsoft_IdentityModel_Logging_ISafeLogSecurityArtifact: never;
 
     readonly Id: string;
@@ -661,12 +713,12 @@ export interface __SecurityToken$views {
     As_ISafeLogSecurityArtifact(): Microsoft_IdentityModel_Logging_Internal.ISafeLogSecurityArtifact$instance;
 }
 
-export interface SecurityToken$instance extends Microsoft_IdentityModel_Logging_Internal.ISafeLogSecurityArtifact$instance {}
-
 export type SecurityToken = SecurityToken$instance & __SecurityToken$views;
 
 
 export interface SecurityTokenArgumentException$instance extends ArgumentException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenArgumentException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -682,6 +734,8 @@ export const SecurityTokenArgumentException: {
 export type SecurityTokenArgumentException = SecurityTokenArgumentException$instance;
 
 export interface SecurityTokenCompressionFailedException$instance extends SecurityTokenException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenCompressionFailedException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -697,6 +751,8 @@ export const SecurityTokenCompressionFailedException: {
 export type SecurityTokenCompressionFailedException = SecurityTokenCompressionFailedException$instance;
 
 export interface SecurityTokenDecompressionFailedException$instance extends SecurityTokenException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenDecompressionFailedException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -712,6 +768,8 @@ export const SecurityTokenDecompressionFailedException: {
 export type SecurityTokenDecompressionFailedException = SecurityTokenDecompressionFailedException$instance;
 
 export interface SecurityTokenDecryptionFailedException$instance extends SecurityTokenException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenDecryptionFailedException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -727,16 +785,18 @@ export const SecurityTokenDecryptionFailedException: {
 export type SecurityTokenDecryptionFailedException = SecurityTokenDecryptionFailedException$instance;
 
 export interface SecurityTokenDescriptor$instance {
-    AdditionalHeaderClaims: IDictionary<System_Internal.String, unknown>;
-    AdditionalInnerHeaderClaims: IDictionary<System_Internal.String, unknown>;
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenDescriptor: never;
+
+    AdditionalHeaderClaims: IDictionary_2<System_Internal.String, unknown>;
+    AdditionalInnerHeaderClaims: IDictionary_2<System_Internal.String, unknown>;
     Audience: string;
-    Claims: IDictionary<System_Internal.String, unknown>;
+    Claims: IDictionary_2<System_Internal.String, unknown>;
     CompressionAlgorithm: string;
     EncryptingCredentials: EncryptingCredentials;
-    Expires: Nullable<DateTime>;
-    IssuedAt: Nullable<DateTime>;
+    Expires: Nullable_1<DateTime>;
+    IssuedAt: Nullable_1<DateTime>;
     Issuer: string;
-    NotBefore: Nullable<DateTime>;
+    NotBefore: Nullable_1<DateTime>;
     SigningCredentials: SigningCredentials;
     Subject: ClaimsIdentity;
     TokenType: string;
@@ -751,6 +811,8 @@ export const SecurityTokenDescriptor: {
 export type SecurityTokenDescriptor = SecurityTokenDescriptor$instance;
 
 export interface SecurityTokenEncryptionFailedException$instance extends SecurityTokenException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenEncryptionFailedException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -766,6 +828,8 @@ export const SecurityTokenEncryptionFailedException: {
 export type SecurityTokenEncryptionFailedException = SecurityTokenEncryptionFailedException$instance;
 
 export interface SecurityTokenEncryptionKeyNotFoundException$instance extends SecurityTokenDecryptionFailedException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenEncryptionKeyNotFoundException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -781,6 +845,8 @@ export const SecurityTokenEncryptionKeyNotFoundException: {
 export type SecurityTokenEncryptionKeyNotFoundException = SecurityTokenEncryptionKeyNotFoundException$instance;
 
 export interface SecurityTokenException$instance extends Exception {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
@@ -797,6 +863,8 @@ export const SecurityTokenException: {
 export type SecurityTokenException = SecurityTokenException$instance;
 
 export interface SecurityTokenExpiredException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenExpiredException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     Expires: DateTime;
@@ -813,7 +881,9 @@ export const SecurityTokenExpiredException: {
 
 export type SecurityTokenExpiredException = SecurityTokenExpiredException$instance;
 
-export interface SecurityTokenHandler$instance extends TokenHandler {
+export interface SecurityTokenHandler$instance extends TokenHandler, ISecurityTokenValidator$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenHandler: never;
+
     readonly __tsonic_iface_Microsoft_IdentityModel_Tokens_ISecurityTokenValidator: never;
 
     readonly CanValidateToken: boolean;
@@ -839,12 +909,12 @@ export interface __SecurityTokenHandler$views {
     As_ISecurityTokenValidator(): ISecurityTokenValidator$instance;
 }
 
-export interface SecurityTokenHandler$instance extends ISecurityTokenValidator$instance {}
-
 export type SecurityTokenHandler = SecurityTokenHandler$instance & __SecurityTokenHandler$views;
 
 
 export interface SecurityTokenInvalidAlgorithmException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenInvalidAlgorithmException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     InvalidAlgorithm: string;
@@ -862,6 +932,8 @@ export const SecurityTokenInvalidAlgorithmException: {
 export type SecurityTokenInvalidAlgorithmException = SecurityTokenInvalidAlgorithmException$instance;
 
 export interface SecurityTokenInvalidAudienceException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenInvalidAudienceException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     InvalidAudience: string;
@@ -879,6 +951,8 @@ export const SecurityTokenInvalidAudienceException: {
 export type SecurityTokenInvalidAudienceException = SecurityTokenInvalidAudienceException$instance;
 
 export interface SecurityTokenInvalidIssuerException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenInvalidIssuerException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     InvalidIssuer: string;
@@ -896,10 +970,12 @@ export const SecurityTokenInvalidIssuerException: {
 export type SecurityTokenInvalidIssuerException = SecurityTokenInvalidIssuerException$instance;
 
 export interface SecurityTokenInvalidLifetimeException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenInvalidLifetimeException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
-    Expires: Nullable<DateTime>;
-    NotBefore: Nullable<DateTime>;
+    Expires: Nullable_1<DateTime>;
+    NotBefore: Nullable_1<DateTime>;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -914,6 +990,8 @@ export const SecurityTokenInvalidLifetimeException: {
 export type SecurityTokenInvalidLifetimeException = SecurityTokenInvalidLifetimeException$instance;
 
 export interface SecurityTokenInvalidSignatureException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenInvalidSignatureException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -929,6 +1007,8 @@ export const SecurityTokenInvalidSignatureException: {
 export type SecurityTokenInvalidSignatureException = SecurityTokenInvalidSignatureException$instance;
 
 export interface SecurityTokenInvalidSigningKeyException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenInvalidSigningKeyException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     SigningKey: SecurityKey;
@@ -945,6 +1025,8 @@ export const SecurityTokenInvalidSigningKeyException: {
 export type SecurityTokenInvalidSigningKeyException = SecurityTokenInvalidSigningKeyException$instance;
 
 export interface SecurityTokenInvalidTypeException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenInvalidTypeException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     InvalidType: string;
@@ -962,6 +1044,8 @@ export const SecurityTokenInvalidTypeException: {
 export type SecurityTokenInvalidTypeException = SecurityTokenInvalidTypeException$instance;
 
 export interface SecurityTokenKeyWrapException$instance extends SecurityTokenException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenKeyWrapException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -977,6 +1061,8 @@ export const SecurityTokenKeyWrapException: {
 export type SecurityTokenKeyWrapException = SecurityTokenKeyWrapException$instance;
 
 export interface SecurityTokenMalformedException$instance extends SecurityTokenArgumentException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenMalformedException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -992,6 +1078,8 @@ export const SecurityTokenMalformedException: {
 export type SecurityTokenMalformedException = SecurityTokenMalformedException$instance;
 
 export interface SecurityTokenNoExpirationException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenNoExpirationException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -1007,6 +1095,8 @@ export const SecurityTokenNoExpirationException: {
 export type SecurityTokenNoExpirationException = SecurityTokenNoExpirationException$instance;
 
 export interface SecurityTokenNotYetValidException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenNotYetValidException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     NotBefore: DateTime;
@@ -1024,6 +1114,8 @@ export const SecurityTokenNotYetValidException: {
 export type SecurityTokenNotYetValidException = SecurityTokenNotYetValidException$instance;
 
 export interface SecurityTokenReplayAddFailedException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenReplayAddFailedException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -1039,6 +1131,8 @@ export const SecurityTokenReplayAddFailedException: {
 export type SecurityTokenReplayAddFailedException = SecurityTokenReplayAddFailedException$instance;
 
 export interface SecurityTokenReplayDetectedException$instance extends SecurityTokenValidationException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenReplayDetectedException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -1054,6 +1148,8 @@ export const SecurityTokenReplayDetectedException: {
 export type SecurityTokenReplayDetectedException = SecurityTokenReplayDetectedException$instance;
 
 export interface SecurityTokenSignatureKeyNotFoundException$instance extends SecurityTokenInvalidSignatureException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenSignatureKeyNotFoundException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -1069,6 +1165,8 @@ export const SecurityTokenSignatureKeyNotFoundException: {
 export type SecurityTokenSignatureKeyNotFoundException = SecurityTokenSignatureKeyNotFoundException$instance;
 
 export interface SecurityTokenUnableToValidateException$instance extends SecurityTokenInvalidSignatureException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenUnableToValidateException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
     ValidationFailure: ValidationFailure;
@@ -1087,6 +1185,8 @@ export const SecurityTokenUnableToValidateException: {
 export type SecurityTokenUnableToValidateException = SecurityTokenUnableToValidateException$instance;
 
 export interface SecurityTokenValidationException$instance extends SecurityTokenException {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenValidationException: never;
+
     readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
 }
@@ -1102,6 +1202,8 @@ export const SecurityTokenValidationException: {
 export type SecurityTokenValidationException = SecurityTokenValidationException$instance;
 
 export interface SignatureProvider$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SignatureProvider: never;
+
     readonly __tsonic_iface_System_IDisposable: never;
 
     Algorithm: string;
@@ -1113,7 +1215,7 @@ export interface SignatureProvider$instance {
     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;
+    Sign(data: ReadOnlySpan_1<System_Internal.Byte>, destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
     Verify(input: byte[], signature: byte[]): boolean;
     Verify(input: byte[], inputOffset: int, inputLength: int, signature: byte[], signatureOffset: int, signatureLength: int): boolean;
 }
@@ -1126,6 +1228,8 @@ export const SignatureProvider: (abstract new(key: SecurityKey, algorithm: strin
 export type SignatureProvider = SignatureProvider$instance;
 
 export interface SigningCredentials$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SigningCredentials: never;
+
     Algorithm: string;
     CryptoProviderFactory: CryptoProviderFactory;
     Digest: string;
@@ -1143,6 +1247,8 @@ export const SigningCredentials: {
 export type SigningCredentials = SigningCredentials$instance;
 
 export interface SymmetricKeyWrapProvider$instance extends KeyWrapProvider {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SymmetricKeyWrapProvider: never;
+
     readonly __tsonic_iface_System_IDisposable: never;
 
     readonly Algorithm: string;
@@ -1165,6 +1271,8 @@ export const SymmetricKeyWrapProvider: {
 export type SymmetricKeyWrapProvider = SymmetricKeyWrapProvider$instance;
 
 export interface SymmetricSecurityKey$instance extends SecurityKey {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SymmetricSecurityKey: never;
+
     readonly Key: byte[];
     readonly KeySize: int;
     CanComputeJwkThumbprint(): boolean;
@@ -1180,6 +1288,8 @@ export const SymmetricSecurityKey: {
 export type SymmetricSecurityKey = SymmetricSecurityKey$instance;
 
 export interface SymmetricSignatureProvider$instance extends SignatureProvider {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SymmetricSignatureProvider: never;
+
     readonly __tsonic_iface_System_IDisposable: never;
 
     MinimumSymmetricKeySizeInBits: int;
@@ -1189,9 +1299,9 @@ export interface SymmetricSignatureProvider$instance extends SignatureProvider {
     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: ReadOnlySpan_1<System_Internal.Byte>, signature: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
     Sign(input: byte[], offset: int, count: int): byte[];
-    Sign(data: ReadOnlySpan<System_Internal.Byte>, destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
+    Sign(data: ReadOnlySpan_1<System_Internal.Byte>, destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
     Verify(input: byte[], signature: byte[]): boolean;
     Verify(input: byte[], signature: byte[], length: int): boolean;
     Verify(input: byte[], inputOffset: int, inputLength: int, signature: byte[], signatureOffset: int, signatureLength: int): boolean;
@@ -1208,6 +1318,8 @@ export const SymmetricSignatureProvider: {
 export type SymmetricSignatureProvider = SymmetricSignatureProvider$instance;
 
 export interface TokenContext$instance extends CallContext {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_TokenContext: never;
+
 }
 
 
@@ -1220,12 +1332,14 @@ export const TokenContext: {
 export type TokenContext = TokenContext$instance;
 
 export interface TokenHandler$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_TokenHandler: never;
+
     MaximumTokenSizeInBytes: int;
     SetDefaultTimesOnTokenCreation: boolean;
     TokenLifetimeInMinutes: int;
     ReadToken(token: string): SecurityToken;
-    ValidateTokenAsync(token: string, validationParameters: TokenValidationParameters): Task<TokenValidationResult>;
-    ValidateTokenAsync(token: SecurityToken, validationParameters: TokenValidationParameters): Task<TokenValidationResult>;
+    ValidateTokenAsync(token: string, validationParameters: TokenValidationParameters): Task_1<TokenValidationResult>;
+    ValidateTokenAsync(token: SecurityToken, validationParameters: TokenValidationParameters): Task_1<TokenValidationResult>;
 }
 
 
@@ -1237,6 +1351,8 @@ export const TokenHandler: (abstract new() => TokenHandler) & {
 export type TokenHandler = TokenHandler$instance;
 
 export interface TokenValidationParameters$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_TokenValidationParameters: never;
+
     ActorValidationParameters: TokenValidationParameters;
     AlgorithmValidator: AlgorithmValidator;
     AudienceValidator: AudienceValidator;
@@ -1247,12 +1363,12 @@ export interface TokenValidationParameters$instance {
     DebugId: string;
     IgnoreTrailingSlashWhenValidatingAudience: boolean;
     IncludeTokenOnFailedValidation: boolean;
-    readonly InstancePropertyBag: IDictionary<System_Internal.String, unknown>;
+    readonly InstancePropertyBag: IDictionary_2<System_Internal.String, unknown>;
     IsClone: boolean;
     IssuerSigningKey: SecurityKey;
     IssuerSigningKeyResolver: IssuerSigningKeyResolver;
     IssuerSigningKeyResolverUsingConfiguration: IssuerSigningKeyResolverUsingConfiguration;
-    IssuerSigningKeys: IEnumerable<SecurityKey>;
+    IssuerSigningKeys: IEnumerable_1<SecurityKey>;
     IssuerSigningKeyValidator: IssuerSigningKeyValidator;
     IssuerSigningKeyValidatorUsingConfiguration: IssuerSigningKeyValidatorUsingConfiguration;
     IssuerValidator: IssuerValidator;
@@ -1261,27 +1377,27 @@ export interface TokenValidationParameters$instance {
     LogTokenId: boolean;
     LogValidationExceptions: boolean;
     NameClaimType: string;
-    NameClaimTypeRetriever: Func<SecurityToken, System_Internal.String, System_Internal.String>;
-    PropertyBag: IDictionary<System_Internal.String, unknown>;
+    NameClaimTypeRetriever: Func_3<SecurityToken, System_Internal.String, System_Internal.String>;
+    PropertyBag: IDictionary_2<System_Internal.String, unknown>;
     RefreshBeforeValidation: boolean;
     RequireAudience: boolean;
     RequireExpirationTime: boolean;
     RequireSignedTokens: boolean;
     RoleClaimType: string;
-    RoleClaimTypeRetriever: Func<SecurityToken, System_Internal.String, System_Internal.String>;
+    RoleClaimTypeRetriever: Func_3<SecurityToken, System_Internal.String, System_Internal.String>;
     SaveSigninToken: boolean;
     SignatureValidator: SignatureValidator;
     SignatureValidatorUsingConfiguration: SignatureValidatorUsingConfiguration;
     TokenDecryptionKey: SecurityKey;
     TokenDecryptionKeyResolver: TokenDecryptionKeyResolver;
-    TokenDecryptionKeys: IEnumerable<SecurityKey>;
+    TokenDecryptionKeys: IEnumerable_1<SecurityKey>;
     TokenReader: TokenReader;
     TokenReplayCache: ITokenReplayCache;
     TokenReplayValidator: TokenReplayValidator;
     TransformBeforeSignatureValidation: TransformBeforeSignatureValidation;
     TryAllIssuerSigningKeys: boolean;
     TypeValidator: TypeValidator;
-    ValidAlgorithms: IEnumerable<System_Internal.String>;
+    ValidAlgorithms: IEnumerable_1<System_Internal.String>;
     ValidateActor: boolean;
     ValidateAudience: boolean;
     ValidateIssuer: boolean;
@@ -1291,10 +1407,10 @@ export interface TokenValidationParameters$instance {
     ValidateTokenReplay: boolean;
     ValidateWithLKG: boolean;
     ValidAudience: string;
-    ValidAudiences: IEnumerable<System_Internal.String>;
+    ValidAudiences: IEnumerable_1<System_Internal.String>;
     ValidIssuer: string;
-    ValidIssuers: IEnumerable<System_Internal.String>;
-    ValidTypes: IEnumerable<System_Internal.String>;
+    ValidIssuers: IEnumerable_1<System_Internal.String>;
+    ValidTypes: IEnumerable_1<System_Internal.String>;
     Clone(): TokenValidationParameters;
     CreateClaimsIdentity(securityToken: SecurityToken, issuer: string): ClaimsIdentity;
 }
@@ -1311,12 +1427,14 @@ export const TokenValidationParameters: {
 export type TokenValidationParameters = TokenValidationParameters$instance;
 
 export interface TokenValidationResult$instance {
-    readonly Claims: IDictionary<System_Internal.String, unknown>;
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_TokenValidationResult: never;
+
+    readonly Claims: IDictionary_2<System_Internal.String, unknown>;
     ClaimsIdentity: ClaimsIdentity;
     Exception: Exception;
     Issuer: string;
     IsValid: boolean;
-    readonly PropertyBag: IDictionary<System_Internal.String, unknown>;
+    readonly PropertyBag: IDictionary_2<System_Internal.String, unknown>;
     SecurityToken: SecurityToken;
     TokenContext: CallContext;
     TokenOnFailedValidation: SecurityToken;
@@ -1332,6 +1450,8 @@ export const TokenValidationResult: {
 export type TokenValidationResult = TokenValidationResult$instance;
 
 export interface X509EncryptingCredentials$instance extends EncryptingCredentials {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_X509EncryptingCredentials: never;
+
     Certificate: X509Certificate2;
 }
 
@@ -1345,6 +1465,8 @@ export const X509EncryptingCredentials: {
 export type X509EncryptingCredentials = X509EncryptingCredentials$instance;
 
 export interface X509SecurityKey$instance extends AsymmetricSecurityKey {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_X509SecurityKey: never;
+
     Certificate: X509Certificate2;
     readonly HasPrivateKey: boolean;
     readonly KeySize: int;
@@ -1368,6 +1490,8 @@ export const X509SecurityKey: {
 export type X509SecurityKey = X509SecurityKey$instance;
 
 export interface X509SigningCredentials$instance extends SigningCredentials {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_X509SigningCredentials: never;
+
     Certificate: X509Certificate2;
 }
 
@@ -1385,7 +1509,7 @@ export abstract class Base64UrlEncoder$instance {
     static DecodeBytes(str: string): byte[];
     static Encode(inArray: byte[], offset: int, length: int): string;
     static Encode(inArray: byte[]): string;
-    static Encode(inArray: ReadOnlySpan<System_Internal.Byte>, output: Span<System_Internal.Char>): int;
+    static Encode(inArray: ReadOnlySpan_1<System_Internal.Byte>, output: Span_1<System_Internal.Char>): int;
     static Encode(arg: string): string;
 }
 
@@ -1393,7 +1517,7 @@ export abstract class Base64UrlEncoder$instance {
 export type Base64UrlEncoder = Base64UrlEncoder$instance;
 
 export abstract class CollectionUtilities$instance {
-    static IsNullOrEmpty<T>(enumerable: IEnumerable<T>): boolean;
+    static IsNullOrEmpty<T>(enumerable: IEnumerable_1<T>): boolean;
 }
 
 
@@ -1404,7 +1528,7 @@ export abstract class DateTimeUtil$instance {
     static GetMaxValue(kind: DateTimeKind): DateTime;
     static GetMinValue(kind: DateTimeKind): DateTime;
     static ToUniversalTime(value: DateTime): DateTime;
-    static ToUniversalTime(value: Nullable<DateTime>): Nullable<DateTime>;
+    static ToUniversalTime(value: Nullable_1<DateTime>): Nullable_1<DateTime>;
 }
 
 
@@ -1572,12 +1696,12 @@ export type Utility = Utility$instance;
 
 export abstract class Validators$instance {
     static ValidateAlgorithm(algorithm: string, securityKey: SecurityKey, securityToken: SecurityToken, validationParameters: TokenValidationParameters): void;
-    static ValidateAudience(audiences: IEnumerable<System_Internal.String>, securityToken: SecurityToken, validationParameters: TokenValidationParameters): void;
+    static ValidateAudience(audiences: IEnumerable_1<System_Internal.String>, securityToken: SecurityToken, validationParameters: TokenValidationParameters): void;
     static ValidateIssuer(issuer: string, securityToken: SecurityToken, validationParameters: TokenValidationParameters): string;
     static ValidateIssuerSecurityKey(securityKey: SecurityKey, securityToken: SecurityToken, validationParameters: TokenValidationParameters): void;
-    static ValidateLifetime(notBefore: Nullable<DateTime>, expires: Nullable<DateTime>, securityToken: SecurityToken, validationParameters: TokenValidationParameters): void;
-    static ValidateTokenReplay(expirationTime: Nullable<DateTime>, securityToken: string, validationParameters: TokenValidationParameters): void;
-    static ValidateTokenReplay(securityToken: string, expirationTime: Nullable<DateTime>, validationParameters: TokenValidationParameters): void;
+    static ValidateLifetime(notBefore: Nullable_1<DateTime>, expires: Nullable_1<DateTime>, securityToken: SecurityToken, validationParameters: TokenValidationParameters): void;
+    static ValidateTokenReplay(expirationTime: Nullable_1<DateTime>, securityToken: string, validationParameters: TokenValidationParameters): void;
+    static ValidateTokenReplay(securityToken: string, expirationTime: Nullable_1<DateTime>, validationParameters: TokenValidationParameters): void;
     static ValidateTokenType(type: string, securityToken: SecurityToken, validationParameters: TokenValidationParameters): string;
 }