@tsonic/efcore-sqlserver 10.0.2 → 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;
@@ -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;
 }
@@ -127,32 +135,33 @@ 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;
 }
 
 
-export const AsymmetricSecurityKey: {
-    new(): AsymmetricSecurityKey;
+export const AsymmetricSecurityKey: (abstract new() => AsymmetricSecurityKey) & {
 };
 
 
 export type AsymmetricSecurityKey = AsymmetricSecurityKey$instance;
 
-export abstract class AsymmetricSignatureProvider$protected {
-    protected Dispose2(disposing: boolean): void;
-    protected GetHashAlgorithmName(algorithm: string): HashAlgorithmName;
-}
+export interface AsymmetricSignatureProvider$instance extends SignatureProvider {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_AsymmetricSignatureProvider: never;
 
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface AsymmetricSignatureProvider$instance extends AsymmetricSignatureProvider$protected, SignatureProvider {
-    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;
-    Sign(input: ReadOnlySpan<System_Internal.Byte>, signature: Span<System_Internal.Byte>, bytesWritten: int): boolean;
+    GetHashAlgorithmName(algorithm: string): HashAlgorithmName;
+    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;
@@ -162,29 +171,29 @@ export interface AsymmetricSignatureProvider$instance extends AsymmetricSignatur
 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 abstract class AuthenticatedEncryptionProvider$protected {
-    protected Dispose(disposing: boolean): void;
-    protected GetKeyBytes(key: SecurityKey): byte[];
-    protected IsSupportedAlgorithm(key: SecurityKey, algorithm: string): boolean;
-    protected ValidateKeySize(key: SecurityKey, algorithm: string): void;
-}
+export interface AuthenticatedEncryptionProvider$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_AuthenticatedEncryptionProvider: never;
 
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface AuthenticatedEncryptionProvider$instance extends AuthenticatedEncryptionProvider$protected {
     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;
 }
 
 
@@ -196,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[];
@@ -211,22 +222,25 @@ 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;
 }
 
 
-export const BaseConfiguration: {
-    new(): BaseConfiguration;
+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;
@@ -234,14 +248,12 @@ export interface BaseConfigurationManager$instance {
     MetadataAddress: string;
     RefreshInterval: TimeSpan;
     UseLastKnownGoodConfiguration: boolean;
-    GetBaseConfigurationAsync(cancel: CancellationToken): Task<BaseConfiguration>;
+    GetBaseConfigurationAsync(cancel: CancellationToken): Task_1<BaseConfiguration>;
     RequestRefresh(): void;
 }
 
 
-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;
@@ -253,6 +265,8 @@ export const BaseConfigurationManager: {
 export type BaseConfigurationManager = BaseConfigurationManager$instance;
 
 export interface CallContext$instance extends LoggerContext {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CallContext: never;
+
 }
 
 
@@ -265,8 +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;
 }
@@ -276,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;
 };
 
@@ -286,6 +304,8 @@ export const CaseSensitiveClaimsIdentity: {
 export type CaseSensitiveClaimsIdentity = CaseSensitiveClaimsIdentity$instance;
 
 export interface CompressionAlgorithms$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CompressionAlgorithms: never;
+
 }
 
 
@@ -298,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;
@@ -314,27 +336,26 @@ export const CompressionProviderFactory: {
 
 export type CompressionProviderFactory = CompressionProviderFactory$instance;
 
-export abstract class CryptoProviderCache$protected {
-    protected abstract GetCacheKey(signatureProvider: SignatureProvider): string;
-    protected abstract GetCacheKey(securityKey: SecurityKey, algorithm: string, typeofProvider: string): string;
-}
-
+export interface CryptoProviderCache$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_CryptoProviderCache: never;
 
-export interface CryptoProviderCache$instance extends CryptoProviderCache$protected {
+    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: {
-    new(): CryptoProviderCache;
+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;
 }
 
@@ -348,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;
@@ -383,7 +406,11 @@ 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;
     CompressionLevel: CompressionLevel;
     MaximumDeflateSize: int;
@@ -403,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;
 }
@@ -422,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;
@@ -439,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;
@@ -449,7 +480,6 @@ export interface EncryptingCredentials$instance {
 
 
 export const EncryptingCredentials: {
-    new(certificate: X509Certificate2, alg: string, enc: string): EncryptingCredentials;
     new(key: SecurityKey, alg: string, enc: string): EncryptingCredentials;
     new(key: SymmetricSecurityKey, enc: string): EncryptingCredentials;
 };
@@ -457,15 +487,15 @@ export const EncryptingCredentials: {
 
 export type EncryptingCredentials = EncryptingCredentials$instance;
 
-export abstract class InMemoryCryptoProviderCache$protected {
-    protected Dispose(disposing: boolean): void;
-    protected GetCacheKey(signatureProvider: SignatureProvider): string;
-    protected GetCacheKey(securityKey: SecurityKey, algorithm: string, typeofProvider: string): string;
-}
+export interface InMemoryCryptoProviderCache$instance extends CryptoProviderCache {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_InMemoryCryptoProviderCache: never;
 
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface InMemoryCryptoProviderCache$instance extends InMemoryCryptoProviderCache$protected, CryptoProviderCache {
     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;
@@ -481,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;
@@ -491,25 +523,25 @@ 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;
     Y: string;
     CanComputeJwkThumbprint(): boolean;
     ComputeJwkThumbprint(): byte[];
-    ToString(): string | undefined;
+    ToString(): string;
 }
 
 
@@ -523,6 +555,8 @@ export const JsonWebKey: {
 export type JsonWebKey = JsonWebKey$instance;
 
 export interface JsonWebKeyConverter$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_JsonWebKeyConverter: never;
+
 }
 
 
@@ -540,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>;
 }
 
 
@@ -557,39 +593,38 @@ export const JsonWebKeySet: {
 
 export type JsonWebKeySet = JsonWebKeySet$instance;
 
-export abstract class KeyWrapProvider$protected {
-    protected abstract Dispose(disposing: boolean): void;
-}
+export interface KeyWrapProvider$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_KeyWrapProvider: never;
 
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface KeyWrapProvider$instance extends KeyWrapProvider$protected {
     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: {
-    new(): KeyWrapProvider;
+export const KeyWrapProvider: (abstract new() => KeyWrapProvider) & {
 };
 
 
 export type KeyWrapProvider = KeyWrapProvider$instance;
 
-export abstract class RsaKeyWrapProvider$protected {
-    protected Dispose2(disposing: boolean): void;
-    protected IsSupportedAlgorithm(key: SecurityKey, algorithm: string): boolean;
-}
+export interface RsaKeyWrapProvider$instance extends KeyWrapProvider {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_RsaKeyWrapProvider: never;
 
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface RsaKeyWrapProvider$instance extends RsaKeyWrapProvider$protected, KeyWrapProvider {
     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[];
 }
@@ -603,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;
@@ -622,24 +659,27 @@ 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;
     CanComputeJwkThumbprint(): boolean;
     ComputeJwkThumbprint(): byte[];
     IsSupportedAlgorithm(algorithm: string): boolean;
-    ToString(): string | undefined;
+    ToString(): string;
 }
 
 
-export const SecurityKey: {
-    new(): SecurityKey;
+export const SecurityKey: (abstract new() => SecurityKey) & {
 };
 
 
 export type SecurityKey = SecurityKey$instance;
 
 export interface SecurityKeyIdentifierClause$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityKeyIdentifierClause: never;
+
 }
 
 
@@ -650,7 +690,11 @@ 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;
     readonly Issuer: string;
     readonly SecurityKey: SecurityKey;
@@ -661,8 +705,7 @@ export interface SecurityToken$instance {
 }
 
 
-export const SecurityToken: {
-    new(): SecurityToken;
+export const SecurityToken: (abstract new() => SecurityToken) & {
 };
 
 
@@ -670,12 +713,14 @@ 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;
+
 }
 
 
@@ -683,13 +728,16 @@ export const SecurityTokenArgumentException: {
     new(): SecurityTokenArgumentException;
     new(message: string): SecurityTokenArgumentException;
     new(message: string, innerException: Exception): SecurityTokenArgumentException;
-    new(info: SerializationInfo, context: StreamingContext): 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,13 +745,16 @@ export const SecurityTokenCompressionFailedException: {
     new(): SecurityTokenCompressionFailedException;
     new(message: string): SecurityTokenCompressionFailedException;
     new(message: string, inner: Exception): SecurityTokenCompressionFailedException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -711,13 +762,16 @@ export const SecurityTokenDecompressionFailedException: {
     new(): SecurityTokenDecompressionFailedException;
     new(message: string): SecurityTokenDecompressionFailedException;
     new(message: string, inner: Exception): SecurityTokenDecompressionFailedException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -725,26 +779,26 @@ export const SecurityTokenDecryptionFailedException: {
     new(): SecurityTokenDecryptionFailedException;
     new(message: string): SecurityTokenDecryptionFailedException;
     new(message: string, innerException: Exception): SecurityTokenDecryptionFailedException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
-    get Subject(): ClaimsIdentity | undefined;
-    set Subject(value: ClaimsIdentity);
+    Subject: ClaimsIdentity;
     TokenType: string;
 }
 
@@ -757,6 +811,10 @@ 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;
+
 }
 
 
@@ -764,13 +822,16 @@ export const SecurityTokenEncryptionFailedException: {
     new(): SecurityTokenEncryptionFailedException;
     new(message: string): SecurityTokenEncryptionFailedException;
     new(message: string, innerException: Exception): SecurityTokenEncryptionFailedException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -778,13 +839,16 @@ export const SecurityTokenEncryptionKeyNotFoundException: {
     new(): SecurityTokenEncryptionKeyNotFoundException;
     new(message: string): SecurityTokenEncryptionKeyNotFoundException;
     new(message: string, innerException: Exception): SecurityTokenEncryptionKeyNotFoundException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
 }
 
@@ -793,13 +857,16 @@ export const SecurityTokenException: {
     new(): SecurityTokenException;
     new(message: string): SecurityTokenException;
     new(message: string, innerException: Exception): SecurityTokenException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -809,13 +876,16 @@ export const SecurityTokenExpiredException: {
     new(): SecurityTokenExpiredException;
     new(message: string): SecurityTokenExpiredException;
     new(message: string, inner: Exception): SecurityTokenExpiredException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
     readonly CanWriteToken: boolean;
     readonly TokenType: Type;
@@ -831,8 +901,7 @@ export interface SecurityTokenHandler$instance extends TokenHandler {
 }
 
 
-export const SecurityTokenHandler: {
-    new(): SecurityTokenHandler;
+export const SecurityTokenHandler: (abstract new() => SecurityTokenHandler) & {
 };
 
 
@@ -840,12 +909,14 @@ 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;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -855,13 +926,16 @@ export const SecurityTokenInvalidAlgorithmException: {
     new(): SecurityTokenInvalidAlgorithmException;
     new(message: string): SecurityTokenInvalidAlgorithmException;
     new(message: string, innerException: Exception): SecurityTokenInvalidAlgorithmException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -871,13 +945,16 @@ export const SecurityTokenInvalidAudienceException: {
     new(): SecurityTokenInvalidAudienceException;
     new(message: string): SecurityTokenInvalidAudienceException;
     new(message: string, innerException: Exception): SecurityTokenInvalidAudienceException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -887,15 +964,18 @@ export const SecurityTokenInvalidIssuerException: {
     new(): SecurityTokenInvalidIssuerException;
     new(message: string): SecurityTokenInvalidIssuerException;
     new(message: string, innerException: Exception): SecurityTokenInvalidIssuerException;
-    new(info: SerializationInfo, context: StreamingContext): SecurityTokenInvalidIssuerException;
 };
 
 
 export type SecurityTokenInvalidIssuerException = SecurityTokenInvalidIssuerException$instance;
 
 export interface SecurityTokenInvalidLifetimeException$instance extends SecurityTokenValidationException {
-    Expires: Nullable<DateTime>;
-    NotBefore: Nullable<DateTime>;
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SecurityTokenInvalidLifetimeException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
+    Expires: Nullable_1<DateTime>;
+    NotBefore: Nullable_1<DateTime>;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
 
@@ -904,13 +984,16 @@ export const SecurityTokenInvalidLifetimeException: {
     new(): SecurityTokenInvalidLifetimeException;
     new(message: string): SecurityTokenInvalidLifetimeException;
     new(message: string, innerException: Exception): SecurityTokenInvalidLifetimeException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -918,13 +1001,16 @@ export const SecurityTokenInvalidSignatureException: {
     new(): SecurityTokenInvalidSignatureException;
     new(message: string): SecurityTokenInvalidSignatureException;
     new(message: string, innerException: Exception): SecurityTokenInvalidSignatureException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
 }
 
@@ -933,13 +1019,16 @@ export const SecurityTokenInvalidSigningKeyException: {
     new(): SecurityTokenInvalidSigningKeyException;
     new(message: string): SecurityTokenInvalidSigningKeyException;
     new(message: string, inner: Exception): SecurityTokenInvalidSigningKeyException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -949,13 +1038,16 @@ export const SecurityTokenInvalidTypeException: {
     new(): SecurityTokenInvalidTypeException;
     new(message: string): SecurityTokenInvalidTypeException;
     new(message: string, innerException: Exception): SecurityTokenInvalidTypeException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -963,13 +1055,16 @@ export const SecurityTokenKeyWrapException: {
     new(): SecurityTokenKeyWrapException;
     new(message: string): SecurityTokenKeyWrapException;
     new(message: string, innerException: Exception): SecurityTokenKeyWrapException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -977,13 +1072,16 @@ export const SecurityTokenMalformedException: {
     new(): SecurityTokenMalformedException;
     new(message: string): SecurityTokenMalformedException;
     new(message: string, innerException: Exception): SecurityTokenMalformedException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -991,13 +1089,16 @@ export const SecurityTokenNoExpirationException: {
     new(): SecurityTokenNoExpirationException;
     new(message: string): SecurityTokenNoExpirationException;
     new(message: string, innerException: Exception): SecurityTokenNoExpirationException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -1007,13 +1108,16 @@ export const SecurityTokenNotYetValidException: {
     new(): SecurityTokenNotYetValidException;
     new(message: string): SecurityTokenNotYetValidException;
     new(message: string, inner: Exception): SecurityTokenNotYetValidException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -1021,13 +1125,16 @@ export const SecurityTokenReplayAddFailedException: {
     new(): SecurityTokenReplayAddFailedException;
     new(message: string): SecurityTokenReplayAddFailedException;
     new(message: string, innerException: Exception): SecurityTokenReplayAddFailedException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -1035,13 +1142,16 @@ export const SecurityTokenReplayDetectedException: {
     new(): SecurityTokenReplayDetectedException;
     new(message: string): SecurityTokenReplayDetectedException;
     new(message: string, inner: Exception): SecurityTokenReplayDetectedException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -1049,13 +1159,16 @@ export const SecurityTokenSignatureKeyNotFoundException: {
     new(): SecurityTokenSignatureKeyNotFoundException;
     new(message: string): SecurityTokenSignatureKeyNotFoundException;
     new(message: string, innerException: Exception): SecurityTokenSignatureKeyNotFoundException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
     GetObjectData(info: SerializationInfo, context: StreamingContext): void;
 }
@@ -1066,13 +1179,16 @@ export const SecurityTokenUnableToValidateException: {
     new(validationFailure: ValidationFailure, message: string): SecurityTokenUnableToValidateException;
     new(message: string): SecurityTokenUnableToValidateException;
     new(message: string, innerException: Exception): SecurityTokenUnableToValidateException;
-    new(info: SerializationInfo, context: StreamingContext): 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;
+
 }
 
 
@@ -1080,40 +1196,40 @@ export const SecurityTokenValidationException: {
     new(): SecurityTokenValidationException;
     new(message: string): SecurityTokenValidationException;
     new(message: string, innerException: Exception): SecurityTokenValidationException;
-    new(info: SerializationInfo, context: StreamingContext): SecurityTokenValidationException;
 };
 
 
 export type SecurityTokenValidationException = SecurityTokenValidationException$instance;
 
-export abstract class SignatureProvider$protected {
-    protected abstract Dispose(disposing: boolean): void;
-}
+export interface SignatureProvider$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SignatureProvider: never;
 
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SignatureProvider$instance extends SignatureProvider$protected {
     Algorithm: string;
     Context: string;
     CryptoProviderCache: CryptoProviderCache;
     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;
+    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;
 }
 
 
-export const SignatureProvider: {
-    new(key: SecurityKey, algorithm: string): SignatureProvider;
+export const SignatureProvider: (abstract new(key: SecurityKey, algorithm: string) => SignatureProvider) & {
 };
 
 
 export type SignatureProvider = SignatureProvider$instance;
 
 export interface SigningCredentials$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SigningCredentials: never;
+
     Algorithm: string;
     CryptoProviderFactory: CryptoProviderFactory;
     Digest: string;
@@ -1123,8 +1239,6 @@ export interface SigningCredentials$instance {
 
 
 export const SigningCredentials: {
-    new(certificate: X509Certificate2): SigningCredentials;
-    new(certificate: X509Certificate2, algorithm: string): SigningCredentials;
     new(key: SecurityKey, algorithm: string): SigningCredentials;
     new(key: SecurityKey, algorithm: string, digest: string): SigningCredentials;
 };
@@ -1132,18 +1246,18 @@ export const SigningCredentials: {
 
 export type SigningCredentials = SigningCredentials$instance;
 
-export abstract class SymmetricKeyWrapProvider$protected {
-    protected Dispose2(disposing: boolean): void;
-    protected GetSymmetricAlgorithm(key: SecurityKey, algorithm: string): SymmetricAlgorithm;
-    protected IsSupportedAlgorithm(key: SecurityKey, algorithm: string): boolean;
-}
+export interface SymmetricKeyWrapProvider$instance extends KeyWrapProvider {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SymmetricKeyWrapProvider: never;
 
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SymmetricKeyWrapProvider$instance extends SymmetricKeyWrapProvider$protected, KeyWrapProvider {
     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[];
 }
@@ -1157,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;
@@ -1171,21 +1287,21 @@ export const SymmetricSecurityKey: {
 
 export type SymmetricSecurityKey = SymmetricSecurityKey$instance;
 
-export abstract class SymmetricSignatureProvider$protected {
-    protected Dispose2(disposing: boolean): void;
-    protected GetKeyBytes(key: SecurityKey): byte[];
-    protected GetKeyedHashAlgorithm(keyBytes: byte[], algorithm: string): KeyedHashAlgorithm;
-    protected ReleaseKeyedHashAlgorithm(keyedHashAlgorithm: KeyedHashAlgorithm): void;
-}
+export interface SymmetricSignatureProvider$instance extends SignatureProvider {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_SymmetricSignatureProvider: never;
 
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SymmetricSignatureProvider$instance extends SymmetricSignatureProvider$protected, SignatureProvider {
     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: 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;
@@ -1202,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;
+
 }
 
 
@@ -1214,17 +1332,18 @@ 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>;
 }
 
 
-export const TokenHandler: {
-    new(): TokenHandler;
+export const TokenHandler: (abstract new() => TokenHandler) & {
     readonly DefaultTokenLifetimeInMinutes: int;
 };
 
@@ -1232,6 +1351,8 @@ export const TokenHandler: {
 export type TokenHandler = TokenHandler$instance;
 
 export interface TokenValidationParameters$instance {
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_TokenValidationParameters: never;
+
     ActorValidationParameters: TokenValidationParameters;
     AlgorithmValidator: AlgorithmValidator;
     AudienceValidator: AudienceValidator;
@@ -1242,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;
@@ -1256,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;
@@ -1286,17 +1407,16 @@ 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;
 }
 
 
 export const TokenValidationParameters: {
-    new(other: TokenValidationParameters): TokenValidationParameters;
     new(): TokenValidationParameters;
     readonly DefaultAuthenticationType: string;
     readonly DefaultClockSkew: TimeSpan;
@@ -1307,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;
@@ -1328,8 +1450,9 @@ export const TokenValidationResult: {
 export type TokenValidationResult = TokenValidationResult$instance;
 
 export interface X509EncryptingCredentials$instance extends EncryptingCredentials {
-    get Certificate(): X509Certificate2 | undefined;
-    set Certificate(value: X509Certificate2);
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_X509EncryptingCredentials: never;
+
+    Certificate: X509Certificate2;
 }
 
 
@@ -1342,8 +1465,9 @@ export const X509EncryptingCredentials: {
 export type X509EncryptingCredentials = X509EncryptingCredentials$instance;
 
 export interface X509SecurityKey$instance extends AsymmetricSecurityKey {
-    get Certificate(): X509Certificate2 | undefined;
-    set Certificate(value: X509Certificate2);
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_X509SecurityKey: never;
+
+    Certificate: X509Certificate2;
     readonly HasPrivateKey: boolean;
     readonly KeySize: int;
     readonly PrivateKey: AsymmetricAlgorithm;
@@ -1366,8 +1490,9 @@ export const X509SecurityKey: {
 export type X509SecurityKey = X509SecurityKey$instance;
 
 export interface X509SigningCredentials$instance extends SigningCredentials {
-    get Certificate(): X509Certificate2 | undefined;
-    set Certificate(value: X509Certificate2);
+    readonly __tsonic_type_Microsoft_IdentityModel_Tokens_X509SigningCredentials: never;
+
+    Certificate: X509Certificate2;
 }
 
 
@@ -1384,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;
 }
 
@@ -1392,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;
 }
 
 
@@ -1403,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>;
 }
 
 
@@ -1571,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;
 }