@tsonic/dotnet-pure/System.Security.Cryptography/internal/index.d.ts

TypeScript type definitions for .NET 10 BCL (Base Class Library) - CLR naming

// Generated by tsbindgen - Architecture
// Namespace: System.Security.Cryptography
// Assembly: System.Private.CoreLib, System.Security.Cryptography

// Branded primitive types are sourced from @tsonic/types
import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/types';

// Import support types from @tsonic/types
import type { ptr, ref } from "@tsonic/types";

// Import types from other namespaces
import type { SafeNCryptKeyHandle, SafeNCryptProviderHandle, SafeNCryptSecretHandle } from "../../Microsoft.Win32.SafeHandles/internal/index.js";
import * as System_Collections_Generic_Internal from "../../System.Collections.Generic/internal/index.js";
import type { ICollection_1, IEnumerable_1, IEnumerator_1, IList_1, IReadOnlyCollection_1, IReadOnlyList_1 } from "../../System.Collections.Generic/internal/index.js";
import * as System_Collections_ObjectModel_Internal from "../../System.Collections.ObjectModel/internal/index.js";
import type { Collection_1 } from "../../System.Collections.ObjectModel/internal/index.js";
import * as System_Collections_Internal from "../../System.Collections/internal/index.js";
import type { ICollection, IDictionary, IEnumerable, IEnumerator, IList } from "../../System.Collections/internal/index.js";
import * as System_IO_Internal from "../../System.IO/internal/index.js";
import type { SeekOrigin, Stream } from "../../System.IO/internal/index.js";
import type { MethodBase } from "../../System.Reflection/internal/index.js";
import * as System_Runtime_InteropServices_Internal from "../../System.Runtime.InteropServices/internal/index.js";
import type { SafeHandle } from "../../System.Runtime.InteropServices/internal/index.js";
import * as System_Runtime_Serialization_Internal from "../../System.Runtime.Serialization/internal/index.js";
import type { ISerializable, SerializationInfo, StreamingContext } from "../../System.Runtime.Serialization/internal/index.js";
import type { SecureString, SecurityElement } from "../../System.Security/internal/index.js";
import type { Task, Task_1, ValueTask, ValueTask_1 } from "../../System.Threading.Tasks/internal/index.js";
import type { CancellationToken } from "../../System.Threading/internal/index.js";
import * as System_Internal from "../../System/internal/index.js";
import type { Array as ClrArray, AsyncCallback, Boolean as ClrBoolean, Byte, Char, Enum, Exception, IAsyncDisposable, IAsyncResult, IComparable, IConvertible, IDisposable, IEquatable_1, IFormatProvider, IFormattable, Int32, Int64, IntPtr, ISpanFormattable, Memory_1, Nullable_1, Object as ClrObject, Range, ReadOnlyMemory_1, ReadOnlySpan_1, Span_1, String as ClrString, SystemException, Type, TypeCode, ValueType, Void } from "../../System/internal/index.js";

// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
// Value positions (parameters, return types) use lowercase primitives for ergonomics
export type CLROf<T> =
    T extends sbyte ? System_Internal.SByte :
    T extends short ? System_Internal.Int16 :
    T extends int ? System_Internal.Int32 :
    T extends long ? System_Internal.Int64 :
    T extends int128 ? System_Internal.Int128 :
    T extends nint ? System_Internal.IntPtr :
    T extends byte ? System_Internal.Byte :
    T extends ushort ? System_Internal.UInt16 :
    T extends uint ? System_Internal.UInt32 :
    T extends ulong ? System_Internal.UInt64 :
    T extends uint128 ? System_Internal.UInt128 :
    T extends nuint ? System_Internal.UIntPtr :
    T extends half ? System_Internal.Half :
    T extends float ? System_Internal.Single :
    T extends double ? System_Internal.Double :
    T extends decimal ? System_Internal.Decimal :
    T extends char ? System_Internal.Char :
    T extends boolean ? System_Internal.Boolean :
    T extends string ? System_Internal.String :
    T; // Identity fallback for non-primitive types

export enum CipherMode {
    CBC = 1,
    ECB = 2,
    OFB = 3,
    CFB = 4,
    CTS = 5
}


export enum CngExportPolicies {
    None = 0,
    AllowExport = 1,
    AllowPlaintextExport = 2,
    AllowArchiving = 4,
    AllowPlaintextArchiving = 8
}


export enum CngKeyCreationOptions {
    None = 0,
    MachineKey = 32,
    OverwriteExistingKey = 128,
    PreferVbs = 65536,
    RequireVbs = 131072,
    UsePerBootKey = 262144
}


export enum CngKeyHandleOpenOptions {
    None = 0,
    EphemeralKey = 1
}


export enum CngKeyOpenOptions {
    None = 0,
    UserKey = 0,
    MachineKey = 32,
    Silent = 64
}


export enum CngKeyUsages {
    None = 0,
    Decryption = 1,
    Signing = 2,
    KeyAgreement = 4,
    AllUsages = 16777215
}


export enum CngPropertyOptions {
    None = 0,
    CustomProperty = 1073741824,
    Persist = -2147483648
}


export enum CngUIProtectionLevels {
    None = 0,
    ProtectKey = 1,
    ForceHighProtection = 2
}


export enum CryptoStreamMode {
    Read = 0,
    Write = 1
}


export enum CspProviderFlags {
    NoFlags = 0,
    UseMachineKeyStore = 1,
    UseDefaultKeyContainer = 2,
    UseNonExportableKey = 4,
    UseExistingKey = 8,
    UseArchivableKey = 16,
    UseUserProtectedKey = 32,
    NoPrompt = 64,
    CreateEphemeralKey = 128
}


export enum DSASignatureFormat {
    IeeeP1363FixedFieldConcatenation = 0,
    Rfc3279DerSequence = 1
}


export enum ECCurve_ECCurveType {
    Implicit = 0,
    PrimeShortWeierstrass = 1,
    PrimeTwistedEdwards = 2,
    PrimeMontgomery = 3,
    Characteristic2 = 4,
    Named = 5
}


export enum ECDiffieHellmanKeyDerivationFunction {
    Hash = 0,
    Hmac = 1,
    Tls = 2
}


export enum ECKeyXmlFormat {
    Rfc4050 = 0
}


export enum FromBase64TransformMode {
    IgnoreWhiteSpaces = 0,
    DoNotIgnoreWhiteSpaces = 1
}


export enum KeyNumber {
    Exchange = 1,
    Signature = 2
}


export enum OidGroup {
    All = 0,
    HashAlgorithm = 1,
    EncryptionAlgorithm = 2,
    PublicKeyAlgorithm = 3,
    SignatureAlgorithm = 4,
    Attribute = 5,
    ExtensionOrAttribute = 6,
    EnhancedKeyUsage = 7,
    Policy = 8,
    Template = 9,
    KeyDerivationFunction = 10
}


export enum PaddingMode {
    None = 1,
    PKCS7 = 2,
    Zeros = 3,
    ANSIX923 = 4,
    ISO10126 = 5
}


export enum PbeEncryptionAlgorithm {
    Unknown = 0,
    Aes128Cbc = 1,
    Aes192Cbc = 2,
    Aes256Cbc = 3,
    TripleDes3KeyPkcs12 = 4
}


export enum RSAEncryptionPaddingMode {
    Pkcs1 = 0,
    Oaep = 1
}


export enum RSASignaturePaddingMode {
    Pkcs1 = 0,
    Pss = 1
}


export interface ICryptoTransform$instance extends IDisposable {
    readonly InputBlockSize: int;
    readonly OutputBlockSize: int;
    readonly CanTransformMultipleBlocks: boolean;
    readonly CanReuseTransform: boolean;
    Dispose(): void;
    TransformBlock(inputBuffer: byte[], inputOffset: int, inputCount: int, outputBuffer: byte[], outputOffset: int): int;
    TransformFinalBlock(inputBuffer: byte[], inputOffset: int, inputCount: int): byte[];
}


export interface ICryptoTransform$instance extends System_Internal.IDisposable$instance {}

export type ICryptoTransform = ICryptoTransform$instance;

export interface ICspAsymmetricAlgorithm$instance {
    readonly CspKeyContainerInfo: CspKeyContainerInfo;
    ExportCspBlob(includePrivateParameters: boolean): byte[];
    ImportCspBlob(rawData: byte[]): void;
}


export type ICspAsymmetricAlgorithm = ICspAsymmetricAlgorithm$instance;

export interface CngProperty$instance {
    readonly Name: string;
    readonly Options: CngPropertyOptions;
    Equals(obj: unknown): boolean;
    Equals(other: CngProperty): boolean;
    GetHashCode(): int;
    GetValue(): byte[];
}


export const CngProperty: {
    new(name: string, value: byte[], options: CngPropertyOptions): CngProperty$instance;
};


export interface __CngProperty$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<CngProperty>;

    // Structural method bridges for numeric interface constraints
    Equals(other: CngProperty): boolean;
}

export type CngProperty = CngProperty$instance & __CngProperty$views;


export interface DSAParameters$instance {
    P: byte[];
    Q: byte[];
    G: byte[];
    Y: byte[];
    J: byte[];
    X: byte[];
    Seed: byte[];
    Counter: int;
}


export const DSAParameters: {
    new(): DSAParameters$instance;
};


export type DSAParameters = DSAParameters$instance;

export interface ECCurve$instance {
    A: byte[];
    B: byte[];
    G: ECPoint;
    Order: byte[];
    Cofactor: byte[];
    Seed: byte[];
    CurveType: ECCurve_ECCurveType;
    Hash: Nullable_1<HashAlgorithmName>;
    Polynomial: byte[];
    Prime: byte[];
    readonly IsCharacteristic2: boolean;
    readonly IsExplicit: boolean;
    readonly IsNamed: boolean;
    readonly IsPrime: boolean;
    readonly Oid: Oid;
    Validate(): void;
}


export const ECCurve: {
    new(): ECCurve$instance;
    CreateFromFriendlyName(oidFriendlyName: string): ECCurve;
    CreateFromOid(curveOid: Oid): ECCurve;
    CreateFromValue(oidValue: string): ECCurve;
};


export type ECCurve = ECCurve$instance;

export interface ECParameters$instance {
    Q: ECPoint;
    D: byte[];
    Curve: ECCurve;
    Validate(): void;
}


export const ECParameters: {
    new(): ECParameters$instance;
};


export type ECParameters = ECParameters$instance;

export interface ECPoint$instance {
    X: byte[];
    Y: byte[];
}


export const ECPoint: {
    new(): ECPoint$instance;
};


export type ECPoint = ECPoint$instance;

export interface HashAlgorithmName$instance {
    readonly Name: string;
    Equals(obj: unknown): boolean;
    Equals(other: HashAlgorithmName): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const HashAlgorithmName: {
    new(name: string): HashAlgorithmName$instance;
    readonly MD5: HashAlgorithmName;
    readonly SHA1: HashAlgorithmName;
    readonly SHA256: HashAlgorithmName;
    readonly SHA384: HashAlgorithmName;
    readonly SHA512: HashAlgorithmName;
    readonly SHA3_256: HashAlgorithmName;
    readonly SHA3_384: HashAlgorithmName;
    readonly SHA3_512: HashAlgorithmName;
    FromOid(oidValue: string): HashAlgorithmName;
    TryFromOid(oidValue: string, value: { value: ref<HashAlgorithmName> }): boolean;
};


export interface __HashAlgorithmName$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<HashAlgorithmName>;

    // Structural method bridges for numeric interface constraints
    Equals(other: HashAlgorithmName): boolean;
}

export type HashAlgorithmName = HashAlgorithmName$instance & __HashAlgorithmName$views;


export interface PemFields$instance {
    readonly Base64Data: Range;
    readonly DecodedDataLength: int;
    readonly Label: Range;
    readonly Location: Range;
}


export const PemFields: {
    new(): PemFields$instance;
};


export type PemFields = PemFields$instance;

export interface RSAParameters$instance {
    D: byte[];
    DP: byte[];
    DQ: byte[];
    Exponent: byte[];
    InverseQ: byte[];
    Modulus: byte[];
    P: byte[];
    Q: byte[];
}


export const RSAParameters: {
    new(): RSAParameters$instance;
};


export type RSAParameters = RSAParameters$instance;

export interface Aes$instance extends SymmetricAlgorithm$instance {
    DecryptKeyWrapPadded(ciphertext: byte[]): byte[];
    DecryptKeyWrapPadded(ciphertext: ReadOnlySpan_1<CLROf<byte>>): byte[];
    DecryptKeyWrapPadded(ciphertext: ReadOnlySpan_1<CLROf<byte>>, destination: Span_1<CLROf<byte>>): int;
    Dispose(): void;
    EncryptKeyWrapPadded(plaintext: byte[]): byte[];
    EncryptKeyWrapPadded(plaintext: ReadOnlySpan_1<CLROf<byte>>): byte[];
    EncryptKeyWrapPadded(plaintext: ReadOnlySpan_1<CLROf<byte>>, destination: Span_1<CLROf<byte>>): void;
    TryDecryptKeyWrapPadded(ciphertext: ReadOnlySpan_1<CLROf<byte>>, destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
}


export const Aes: {
    GetKeyWrapPaddedLength(plaintextLengthInBytes: int): int;
};


export interface __Aes$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type Aes = Aes$instance & __Aes$views;


export interface AesCcm$instance {
    Decrypt(nonce: byte[], ciphertext: byte[], tag: byte[], plaintext: byte[], associatedData?: byte[]): void;
    Decrypt(nonce: ReadOnlySpan_1<CLROf<byte>>, ciphertext: ReadOnlySpan_1<CLROf<byte>>, tag: ReadOnlySpan_1<CLROf<byte>>, plaintext: Span_1<CLROf<byte>>, associatedData?: ReadOnlySpan_1<CLROf<byte>>): void;
    Dispose(): void;
    Encrypt(nonce: byte[], plaintext: byte[], ciphertext: byte[], tag: byte[], associatedData?: byte[]): void;
    Encrypt(nonce: ReadOnlySpan_1<CLROf<byte>>, plaintext: ReadOnlySpan_1<CLROf<byte>>, ciphertext: Span_1<CLROf<byte>>, tag: Span_1<CLROf<byte>>, associatedData?: ReadOnlySpan_1<CLROf<byte>>): void;
}


export const AesCcm: {
    new(key: ReadOnlySpan_1<CLROf<byte>>): AesCcm$instance;
    new(key: byte[]): AesCcm$instance;
    readonly NonceByteSizes: KeySizes;
    readonly TagByteSizes: KeySizes;
    readonly IsSupported: boolean;
};


export interface __AesCcm$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface AesCcm$instance extends System_Internal.IDisposable$instance {}

export type AesCcm = AesCcm$instance & __AesCcm$views;


export interface AesCng$instance extends Aes$instance {
    CreateDecryptor(rgbKey: byte[], rgbIV: byte[]): ICryptoTransform;
    CreateDecryptor(): ICryptoTransform;
    CreateEncryptor(rgbKey: byte[], rgbIV: byte[]): ICryptoTransform;
    CreateEncryptor(): ICryptoTransform;
    Dispose(): void;
    GenerateIV(): void;
    GenerateKey(): void;
}


export const AesCng: {
    new(): AesCng$instance;
    new(keyName: string): AesCng$instance;
    new(keyName: string, provider: CngProvider): AesCng$instance;
    new(keyName: string, provider: CngProvider, openOptions: CngKeyOpenOptions): AesCng$instance;
    new(key: CngKey): AesCng$instance;
};


export interface __AesCng$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type AesCng = AesCng$instance & __AesCng$views;


export interface AesCryptoServiceProvider$instance extends Aes$instance {
    BlockSize: int;
    FeedbackSize: int;
    IV: byte[];
    Key: byte[];
    KeySize: int;
    readonly LegalBlockSizes: KeySizes[];
    readonly LegalKeySizes: KeySizes[];
    Mode: CipherMode;
    Padding: PaddingMode;
    CreateDecryptor(): ICryptoTransform;
    CreateDecryptor(rgbKey: byte[], rgbIV: byte[]): ICryptoTransform;
    CreateEncryptor(): ICryptoTransform;
    CreateEncryptor(rgbKey: byte[], rgbIV: byte[]): ICryptoTransform;
    Dispose(): void;
    GenerateIV(): void;
    GenerateKey(): void;
}


export const AesCryptoServiceProvider: {
    new(): AesCryptoServiceProvider$instance;
};


export interface __AesCryptoServiceProvider$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type AesCryptoServiceProvider = AesCryptoServiceProvider$instance & __AesCryptoServiceProvider$views;


export interface AesGcm$instance {
    readonly TagSizeInBytes: Nullable_1<CLROf<int>>;
    Decrypt(nonce: byte[], ciphertext: byte[], tag: byte[], plaintext: byte[], associatedData?: byte[]): void;
    Decrypt(nonce: ReadOnlySpan_1<CLROf<byte>>, ciphertext: ReadOnlySpan_1<CLROf<byte>>, tag: ReadOnlySpan_1<CLROf<byte>>, plaintext: Span_1<CLROf<byte>>, associatedData?: ReadOnlySpan_1<CLROf<byte>>): void;
    Dispose(): void;
    Encrypt(nonce: byte[], plaintext: byte[], ciphertext: byte[], tag: byte[], associatedData?: byte[]): void;
    Encrypt(nonce: ReadOnlySpan_1<CLROf<byte>>, plaintext: ReadOnlySpan_1<CLROf<byte>>, ciphertext: Span_1<CLROf<byte>>, tag: Span_1<CLROf<byte>>, associatedData?: ReadOnlySpan_1<CLROf<byte>>): void;
}


export const AesGcm: {
    new(key: ReadOnlySpan_1<CLROf<byte>>, tagSizeInBytes: int): AesGcm$instance;
    new(key: byte[], tagSizeInBytes: int): AesGcm$instance;
    new(key: ReadOnlySpan_1<CLROf<byte>>): AesGcm$instance;
    new(key: byte[]): AesGcm$instance;
    readonly NonceByteSizes: KeySizes;
    readonly TagByteSizes: KeySizes;
    readonly IsSupported: boolean;
};


export interface __AesGcm$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface AesGcm$instance extends System_Internal.IDisposable$instance {}

export type AesGcm = AesGcm$instance & __AesGcm$views;


export interface AesManaged$instance extends Aes$instance {
    BlockSize: int;
    FeedbackSize: int;
    IV: byte[];
    Key: byte[];
    KeySize: int;
    readonly LegalBlockSizes: KeySizes[];
    readonly LegalKeySizes: KeySizes[];
    Mode: CipherMode;
    Padding: PaddingMode;
    CreateDecryptor(): ICryptoTransform;
    CreateDecryptor(rgbKey: byte[], rgbIV: byte[]): ICryptoTransform;
    CreateEncryptor(): ICryptoTransform;
    CreateEncryptor(rgbKey: byte[], rgbIV: byte[]): ICryptoTransform;
    Dispose(): void;
    GenerateIV(): void;
    GenerateKey(): void;
}


export const AesManaged: {
    new(): AesManaged$instance;
};


export interface __AesManaged$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type AesManaged = AesManaged$instance & __AesManaged$views;


export interface AsnEncodedData$instance {
    Oid: Oid;
    RawData: byte[];
    CopyFrom(asnEncodedData: AsnEncodedData): void;
    Format(multiLine: boolean): string;
}


export const AsnEncodedData: {
    new(rawData: byte[]): AsnEncodedData$instance;
    new(rawData: ReadOnlySpan_1<CLROf<byte>>): AsnEncodedData$instance;
    new(asnEncodedData: AsnEncodedData): AsnEncodedData$instance;
    new(oid: Oid, rawData: byte[]): AsnEncodedData$instance;
    new(oid: string, rawData: byte[]): AsnEncodedData$instance;
    new(oid: Oid, rawData: ReadOnlySpan_1<CLROf<byte>>): AsnEncodedData$instance;
    new(oid: string, rawData: ReadOnlySpan_1<CLROf<byte>>): AsnEncodedData$instance;
};


export type AsnEncodedData = AsnEncodedData$instance;

export interface AsnEncodedDataCollection$instance {
    readonly Count: int;
    readonly IsSynchronized: boolean;
    readonly Item: AsnEncodedData;
    readonly SyncRoot: unknown;
    Add(asnEncodedData: AsnEncodedData): int;
    CopyTo(array: AsnEncodedData[], index: int): void;
    GetEnumerator(): AsnEncodedDataEnumerator;
    Remove(asnEncodedData: AsnEncodedData): void;
}


export const AsnEncodedDataCollection: {
    new(): AsnEncodedDataCollection$instance;
    new(asnEncodedData: AsnEncodedData): AsnEncodedDataCollection$instance;
};


export interface __AsnEncodedDataCollection$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export type AsnEncodedDataCollection = AsnEncodedDataCollection$instance & __AsnEncodedDataCollection$views;


export interface AsnEncodedDataEnumerator$instance {
    readonly Current: AsnEncodedData | unknown;
    MoveNext(): boolean;
    Reset(): void;
}


export const AsnEncodedDataEnumerator: {
    new(): AsnEncodedDataEnumerator$instance;
};


export interface __AsnEncodedDataEnumerator$views {
    As_IEnumerator(): System_Collections_Internal.IEnumerator$instance;
}

export type AsnEncodedDataEnumerator = AsnEncodedDataEnumerator$instance & __AsnEncodedDataEnumerator$views;


export interface AsymmetricAlgorithm$instance {
    readonly KeyExchangeAlgorithm: string;
    KeySize: int;
    readonly LegalKeySizes: KeySizes[];
    readonly SignatureAlgorithm: string;
    Clear(): void;
    Dispose(): void;
    ExportEncryptedPkcs8PrivateKey(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, pbeParameters: PbeParameters): byte[];
    ExportEncryptedPkcs8PrivateKey(password: ReadOnlySpan_1<CLROf<char>>, pbeParameters: PbeParameters): byte[];
    ExportEncryptedPkcs8PrivateKeyPem(password: ReadOnlySpan_1<CLROf<char>>, pbeParameters: PbeParameters): string;
    ExportEncryptedPkcs8PrivateKeyPem(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, pbeParameters: PbeParameters): string;
    ExportPkcs8PrivateKey(): byte[];
    ExportPkcs8PrivateKeyPem(): string;
    ExportSubjectPublicKeyInfo(): byte[];
    ExportSubjectPublicKeyInfoPem(): string;
    FromXmlString(xmlString: string): void;
    ImportEncryptedPkcs8PrivateKey(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, source: ReadOnlySpan_1<CLROf<byte>>, bytesRead: { value: ref<int> }): void;
    ImportEncryptedPkcs8PrivateKey(password: ReadOnlySpan_1<CLROf<char>>, source: ReadOnlySpan_1<CLROf<byte>>, bytesRead: { value: ref<int> }): void;
    ImportFromEncryptedPem(input: ReadOnlySpan_1<CLROf<char>>, password: ReadOnlySpan_1<CLROf<char>>): void;
    ImportFromEncryptedPem(input: ReadOnlySpan_1<CLROf<char>>, passwordBytes: ReadOnlySpan_1<CLROf<byte>>): void;
    ImportFromPem(input: ReadOnlySpan_1<CLROf<char>>): void;
    ImportPkcs8PrivateKey(source: ReadOnlySpan_1<CLROf<byte>>, bytesRead: { value: ref<int> }): void;
    ImportSubjectPublicKeyInfo(source: ReadOnlySpan_1<CLROf<byte>>, bytesRead: { value: ref<int> }): void;
    ToXmlString(includePrivateParameters: boolean): string;
    TryExportEncryptedPkcs8PrivateKey(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, pbeParameters: PbeParameters, destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportEncryptedPkcs8PrivateKey(password: ReadOnlySpan_1<CLROf<char>>, pbeParameters: PbeParameters, destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportEncryptedPkcs8PrivateKeyPem(password: ReadOnlySpan_1<CLROf<char>>, pbeParameters: PbeParameters, destination: Span_1<CLROf<char>>, charsWritten: { value: ref<int> }): boolean;
    TryExportEncryptedPkcs8PrivateKeyPem(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, pbeParameters: PbeParameters, destination: Span_1<CLROf<char>>, charsWritten: { value: ref<int> }): boolean;
    TryExportPkcs8PrivateKey(destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportPkcs8PrivateKeyPem(destination: Span_1<CLROf<char>>, charsWritten: { value: ref<int> }): boolean;
    TryExportSubjectPublicKeyInfo(destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportSubjectPublicKeyInfoPem(destination: Span_1<CLROf<char>>, charsWritten: { value: ref<int> }): boolean;
}


export const AsymmetricAlgorithm: {
    Create(): AsymmetricAlgorithm;
    Create(algName: string): AsymmetricAlgorithm;
};


export interface __AsymmetricAlgorithm$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface AsymmetricAlgorithm$instance extends System_Internal.IDisposable$instance {}

export type AsymmetricAlgorithm = AsymmetricAlgorithm$instance & __AsymmetricAlgorithm$views;


export interface AsymmetricKeyExchangeDeformatter$instance {
    Parameters: string;
    DecryptKeyExchange(rgb: byte[]): byte[];
    SetKey(key: AsymmetricAlgorithm): void;
}


export const AsymmetricKeyExchangeDeformatter: {
};


export type AsymmetricKeyExchangeDeformatter = AsymmetricKeyExchangeDeformatter$instance;

export interface AsymmetricKeyExchangeFormatter$instance {
    readonly Parameters: string;
    CreateKeyExchange(data: byte[]): byte[];
    CreateKeyExchange(data: byte[], symAlgType: Type): byte[];
    SetKey(key: AsymmetricAlgorithm): void;
}


export const AsymmetricKeyExchangeFormatter: {
};


export type AsymmetricKeyExchangeFormatter = AsymmetricKeyExchangeFormatter$instance;

export interface AsymmetricSignatureDeformatter$instance {
    SetHashAlgorithm(strName: string): void;
    SetKey(key: AsymmetricAlgorithm): void;
    VerifySignature(hash: HashAlgorithm, rgbSignature: byte[]): boolean;
    VerifySignature(rgbHash: byte[], rgbSignature: byte[]): boolean;
}


export const AsymmetricSignatureDeformatter: {
};


export type AsymmetricSignatureDeformatter = AsymmetricSignatureDeformatter$instance;

export interface AsymmetricSignatureFormatter$instance {
    CreateSignature(hash: HashAlgorithm): byte[];
    CreateSignature(rgbHash: byte[]): byte[];
    SetHashAlgorithm(strName: string): void;
    SetKey(key: AsymmetricAlgorithm): void;
}


export const AsymmetricSignatureFormatter: {
};


export type AsymmetricSignatureFormatter = AsymmetricSignatureFormatter$instance;

export interface AuthenticationTagMismatchException$instance extends CryptographicException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const AuthenticationTagMismatchException: {
    new(): AuthenticationTagMismatchException$instance;
    new(message: string): AuthenticationTagMismatchException$instance;
    new(message: string, inner: Exception): AuthenticationTagMismatchException$instance;
};


export interface __AuthenticationTagMismatchException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type AuthenticationTagMismatchException = AuthenticationTagMismatchException$instance & __AuthenticationTagMismatchException$views;


export interface ChaCha20Poly1305$instance {
    Decrypt(nonce: byte[], ciphertext: byte[], tag: byte[], plaintext: byte[], associatedData?: byte[]): void;
    Decrypt(nonce: ReadOnlySpan_1<CLROf<byte>>, ciphertext: ReadOnlySpan_1<CLROf<byte>>, tag: ReadOnlySpan_1<CLROf<byte>>, plaintext: Span_1<CLROf<byte>>, associatedData?: ReadOnlySpan_1<CLROf<byte>>): void;
    Dispose(): void;
    Encrypt(nonce: byte[], plaintext: byte[], ciphertext: byte[], tag: byte[], associatedData?: byte[]): void;
    Encrypt(nonce: ReadOnlySpan_1<CLROf<byte>>, plaintext: ReadOnlySpan_1<CLROf<byte>>, ciphertext: Span_1<CLROf<byte>>, tag: Span_1<CLROf<byte>>, associatedData?: ReadOnlySpan_1<CLROf<byte>>): void;
}


export const ChaCha20Poly1305: {
    new(key: ReadOnlySpan_1<CLROf<byte>>): ChaCha20Poly1305$instance;
    new(key: byte[]): ChaCha20Poly1305$instance;
    readonly IsSupported: boolean;
};


export interface __ChaCha20Poly1305$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface ChaCha20Poly1305$instance extends System_Internal.IDisposable$instance {}

export type ChaCha20Poly1305 = ChaCha20Poly1305$instance & __ChaCha20Poly1305$views;


export interface CngAlgorithm$instance {
    readonly Algorithm: string;
    Equals(obj: unknown): boolean;
    Equals(other: CngAlgorithm): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const CngAlgorithm: {
    new(algorithm: string): CngAlgorithm$instance;
    readonly Rsa: CngAlgorithm;
    readonly ECDiffieHellman: CngAlgorithm;
    readonly ECDiffieHellmanP256: CngAlgorithm;
    readonly ECDiffieHellmanP384: CngAlgorithm;
    readonly ECDiffieHellmanP521: CngAlgorithm;
    readonly ECDsa: CngAlgorithm;
    readonly ECDsaP256: CngAlgorithm;
    readonly ECDsaP384: CngAlgorithm;
    readonly ECDsaP521: CngAlgorithm;
    readonly MD5: CngAlgorithm;
    readonly Sha1: CngAlgorithm;
    readonly Sha256: CngAlgorithm;
    readonly Sha384: CngAlgorithm;
    readonly Sha512: CngAlgorithm;
    readonly MLDsa: CngAlgorithm;
    readonly MLKem: CngAlgorithm;
    readonly SlhDsa: CngAlgorithm;
};


export interface __CngAlgorithm$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<CngAlgorithm>;

    // Structural method bridges for numeric interface constraints
    Equals(other: CngAlgorithm): boolean;
}

export type CngAlgorithm = CngAlgorithm$instance & __CngAlgorithm$views;


export interface CngAlgorithmGroup$instance {
    readonly AlgorithmGroup: string;
    Equals(obj: unknown): boolean;
    Equals(other: CngAlgorithmGroup): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const CngAlgorithmGroup: {
    new(algorithmGroup: string): CngAlgorithmGroup$instance;
    readonly DiffieHellman: CngAlgorithmGroup;
    readonly Dsa: CngAlgorithmGroup;
    readonly ECDiffieHellman: CngAlgorithmGroup;
    readonly ECDsa: CngAlgorithmGroup;
    readonly Rsa: CngAlgorithmGroup;
    readonly MLDsa: CngAlgorithmGroup;
    readonly MLKem: CngAlgorithmGroup;
    readonly SlhDsa: CngAlgorithmGroup;
};


export interface __CngAlgorithmGroup$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<CngAlgorithmGroup>;

    // Structural method bridges for numeric interface constraints
    Equals(other: CngAlgorithmGroup): boolean;
}

export type CngAlgorithmGroup = CngAlgorithmGroup$instance & __CngAlgorithmGroup$views;


export interface CngKey$instance {
    readonly Algorithm: CngAlgorithm;
    readonly AlgorithmGroup: CngAlgorithmGroup;
    readonly ExportPolicy: CngExportPolicies;
    readonly Handle: SafeNCryptKeyHandle;
    readonly IsEphemeral: boolean;
    readonly IsMachineKey: boolean;
    readonly KeyName: string;
    readonly KeySize: int;
    readonly KeyUsage: CngKeyUsages;
    ParentWindowHandle: nint;
    readonly Provider: CngProvider;
    readonly ProviderHandle: SafeNCryptProviderHandle;
    readonly UIPolicy: CngUIPolicy;
    readonly UniqueName: string;
    Delete(): void;
    Dispose(): void;
    Export(format: CngKeyBlobFormat): byte[];
    GetProperty(name: string, options: CngPropertyOptions): CngProperty;
    HasProperty(name: string, options: CngPropertyOptions): boolean;
    SetProperty(property: CngProperty): void;
}


export const CngKey: {
    new(): CngKey$instance;
    Create(algorithm: CngAlgorithm, keyName: string, creationParameters: CngKeyCreationParameters): CngKey;
    Create(algorithm: CngAlgorithm, keyName: string): CngKey;
    Create(algorithm: CngAlgorithm): CngKey;
    Exists(keyName: string, provider: CngProvider, options: CngKeyOpenOptions): boolean;
    Exists(keyName: string, provider: CngProvider): boolean;
    Exists(keyName: string): boolean;
    Import(keyBlob: byte[], format: CngKeyBlobFormat, provider: CngProvider): CngKey;
    Import(keyBlob: byte[], format: CngKeyBlobFormat): CngKey;
    Open(keyHandle: SafeNCryptKeyHandle, keyHandleOpenOptions: CngKeyHandleOpenOptions): CngKey;
    Open(keyName: string, provider: CngProvider, openOptions: CngKeyOpenOptions): CngKey;
    Open(keyName: string, provider: CngProvider): CngKey;
    Open(keyName: string): CngKey;
};


export interface __CngKey$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface CngKey$instance extends System_Internal.IDisposable$instance {}

export type CngKey = CngKey$instance & __CngKey$views;


export interface CngKeyBlobFormat$instance {
    readonly Format: string;
    Equals(obj: unknown): boolean;
    Equals(other: CngKeyBlobFormat): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const CngKeyBlobFormat: {
    new(format: string): CngKeyBlobFormat$instance;
    readonly EccPrivateBlob: CngKeyBlobFormat;
    readonly EccPublicBlob: CngKeyBlobFormat;
    readonly EccFullPrivateBlob: CngKeyBlobFormat;
    readonly EccFullPublicBlob: CngKeyBlobFormat;
    readonly GenericPrivateBlob: CngKeyBlobFormat;
    readonly GenericPublicBlob: CngKeyBlobFormat;
    readonly PQDsaPublicBlob: CngKeyBlobFormat;
    readonly PQDsaPrivateBlob: CngKeyBlobFormat;
    readonly PQDsaPrivateSeedBlob: CngKeyBlobFormat;
    readonly MLKemPublicBlob: CngKeyBlobFormat;
    readonly MLKemPrivateBlob: CngKeyBlobFormat;
    readonly MLKemPrivateSeedBlob: CngKeyBlobFormat;
    readonly OpaqueTransportBlob: CngKeyBlobFormat;
    readonly Pkcs8PrivateBlob: CngKeyBlobFormat;
};


export interface __CngKeyBlobFormat$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<CngKeyBlobFormat>;

    // Structural method bridges for numeric interface constraints
    Equals(other: CngKeyBlobFormat): boolean;
}

export type CngKeyBlobFormat = CngKeyBlobFormat$instance & __CngKeyBlobFormat$views;


export interface CngKeyCreationParameters$instance {
    ExportPolicy: Nullable_1<CngExportPolicies>;
    KeyCreationOptions: CngKeyCreationOptions;
    KeyUsage: Nullable_1<CngKeyUsages>;
    readonly Parameters: CngPropertyCollection;
    ParentWindowHandle: nint;
    Provider: CngProvider;
    UIPolicy: CngUIPolicy;
}


export const CngKeyCreationParameters: {
    new(): CngKeyCreationParameters$instance;
};


export type CngKeyCreationParameters = CngKeyCreationParameters$instance;

export interface CngPropertyCollection$instance extends Collection_1<CngProperty> {
    Add(item: CngProperty): void;
    Add(value: unknown): int;
    Clear(): void;
    Contains(item: CngProperty): boolean;
    Contains(value: unknown): boolean;
    CopyTo(array: CngProperty[], index: int): void;
    CopyTo(array: ClrArray, index: int): void;
    GetEnumerator(): IEnumerator_1<CngProperty>;
    GetEnumerator(): IEnumerator;
    IndexOf(item: CngProperty): int;
    Insert(index: int, item: CngProperty): void;
    Insert(index: int, value: unknown): void;
    Remove(item: CngProperty): boolean;
    Remove(value: unknown): void;
    RemoveAt(index: int): void;
}


export const CngPropertyCollection: {
    new(): CngPropertyCollection$instance;
};


export interface __CngPropertyCollection$views {
    As_ICollection_1(): System_Collections_Generic_Internal.ICollection_1$instance<CngProperty>;
    As_IEnumerable_1(): System_Collections_Generic_Internal.IEnumerable_1$instance<CngProperty>;
    As_IList_1(): System_Collections_Generic_Internal.IList_1$instance<CngProperty>;
    As_IReadOnlyCollection_1(): System_Collections_Generic_Internal.IReadOnlyCollection_1$instance<CngProperty>;
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
    As_IList(): System_Collections_Internal.IList$instance;
}

export type CngPropertyCollection = CngPropertyCollection$instance & __CngPropertyCollection$views;


export interface CngProvider$instance {
    readonly Provider: string;
    Equals(obj: unknown): boolean;
    Equals(other: CngProvider): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const CngProvider: {
    new(provider: string): CngProvider$instance;
    readonly MicrosoftPlatformCryptoProvider: CngProvider;
    readonly MicrosoftSmartCardKeyStorageProvider: CngProvider;
    readonly MicrosoftSoftwareKeyStorageProvider: CngProvider;
};


export interface __CngProvider$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<CngProvider>;

    // Structural method bridges for numeric interface constraints
    Equals(other: CngProvider): boolean;
}

export type CngProvider = CngProvider$instance & __CngProvider$views;


export interface CngUIPolicy$instance {
    readonly CreationTitle: string;
    readonly Description: string;
    readonly FriendlyName: string;
    readonly ProtectionLevel: CngUIProtectionLevels;
    readonly UseContext: string;
}


export const CngUIPolicy: {
    new(protectionLevel: CngUIProtectionLevels): CngUIPolicy$instance;
    new(protectionLevel: CngUIProtectionLevels, friendlyName: string): CngUIPolicy$instance;
    new(protectionLevel: CngUIProtectionLevels, friendlyName: string, description: string): CngUIPolicy$instance;
    new(protectionLevel: CngUIProtectionLevels, friendlyName: string, description: string, useContext: string): CngUIPolicy$instance;
    new(protectionLevel: CngUIProtectionLevels, friendlyName: string, description: string, useContext: string, creationTitle: string): CngUIPolicy$instance;
};


export type CngUIPolicy = CngUIPolicy$instance;

export interface CompositeMLDsa$instance {
    readonly Algorithm: CompositeMLDsaAlgorithm;
    Dispose(): void;
    ExportCompositeMLDsaPrivateKey(): byte[];
    ExportCompositeMLDsaPrivateKey(destination: Span_1<CLROf<byte>>): int;
    ExportCompositeMLDsaPublicKey(): byte[];
    ExportCompositeMLDsaPublicKey(destination: Span_1<CLROf<byte>>): int;
    ExportEncryptedPkcs8PrivateKey(password: string, pbeParameters: PbeParameters): byte[];
    ExportEncryptedPkcs8PrivateKey(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, pbeParameters: PbeParameters): byte[];
    ExportEncryptedPkcs8PrivateKey(password: ReadOnlySpan_1<CLROf<char>>, pbeParameters: PbeParameters): byte[];
    ExportEncryptedPkcs8PrivateKeyPem(password: string, pbeParameters: PbeParameters): string;
    ExportEncryptedPkcs8PrivateKeyPem(password: ReadOnlySpan_1<CLROf<char>>, pbeParameters: PbeParameters): string;
    ExportEncryptedPkcs8PrivateKeyPem(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, pbeParameters: PbeParameters): string;
    ExportPkcs8PrivateKey(): byte[];
    ExportPkcs8PrivateKeyPem(): string;
    ExportSubjectPublicKeyInfo(): byte[];
    ExportSubjectPublicKeyInfoPem(): string;
    SignData(data: byte[], context?: byte[]): byte[];
    SignData(data: ReadOnlySpan_1<CLROf<byte>>, destination: Span_1<CLROf<byte>>, context?: ReadOnlySpan_1<CLROf<byte>>): int;
    TryExportCompositeMLDsaPrivateKey(destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportCompositeMLDsaPublicKey(destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportEncryptedPkcs8PrivateKey(password: string, pbeParameters: PbeParameters, destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportEncryptedPkcs8PrivateKey(password: ReadOnlySpan_1<CLROf<char>>, pbeParameters: PbeParameters, destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportEncryptedPkcs8PrivateKey(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, pbeParameters: PbeParameters, destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportPkcs8PrivateKey(destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    TryExportSubjectPublicKeyInfo(destination: Span_1<CLROf<byte>>, bytesWritten: { value: ref<int> }): boolean;
    VerifyData(data: byte[], signature: byte[], context?: byte[]): boolean;
    VerifyData(data: ReadOnlySpan_1<CLROf<byte>>, signature: ReadOnlySpan_1<CLROf<byte>>, context?: ReadOnlySpan_1<CLROf<byte>>): boolean;
}


export const CompositeMLDsa: {
    readonly IsSupported: boolean;
    GenerateKey(algorithm: CompositeMLDsaAlgorithm): CompositeMLDsa;
    ImportCompositeMLDsaPrivateKey(algorithm: CompositeMLDsaAlgorithm, source: byte[]): CompositeMLDsa;
    ImportCompositeMLDsaPrivateKey(algorithm: CompositeMLDsaAlgorithm, source: ReadOnlySpan_1<CLROf<byte>>): CompositeMLDsa;
    ImportCompositeMLDsaPublicKey(algorithm: CompositeMLDsaAlgorithm, source: byte[]): CompositeMLDsa;
    ImportCompositeMLDsaPublicKey(algorithm: CompositeMLDsaAlgorithm, source: ReadOnlySpan_1<CLROf<byte>>): CompositeMLDsa;
    ImportEncryptedPkcs8PrivateKey(passwordBytes: ReadOnlySpan_1<CLROf<byte>>, source: ReadOnlySpan_1<CLROf<byte>>): CompositeMLDsa;
    ImportEncryptedPkcs8PrivateKey(password: ReadOnlySpan_1<CLROf<char>>, source: ReadOnlySpan_1<CLROf<byte>>): CompositeMLDsa;
    ImportEncryptedPkcs8PrivateKey(password: string, source: byte[]): CompositeMLDsa;
    ImportFromEncryptedPem(source: ReadOnlySpan_1<CLROf<char>>, passwordBytes: ReadOnlySpan_1<CLROf<byte>>): CompositeMLDsa;
    ImportFromEncryptedPem(source: ReadOnlySpan_1<CLROf<char>>, password: ReadOnlySpan_1<CLROf<char>>): CompositeMLDsa;
    ImportFromEncryptedPem(source: string, passwordBytes: byte[]): CompositeMLDsa;
    ImportFromEncryptedPem(source: string, password: string): CompositeMLDsa;
    ImportFromPem(source: ReadOnlySpan_1<CLROf<char>>): CompositeMLDsa;
    ImportFromPem(source: string): CompositeMLDsa;
    ImportPkcs8PrivateKey(source: byte[]): CompositeMLDsa;
    ImportPkcs8PrivateKey(source: ReadOnlySpan_1<CLROf<byte>>): CompositeMLDsa;
    ImportSubjectPublicKeyInfo(source: byte[]): CompositeMLDsa;
    ImportSubjectPublicKeyInfo(source: ReadOnlySpan_1<CLROf<byte>>): CompositeMLDsa;
    IsAlgorithmSupported(algorithm: CompositeMLDsaAlgorithm): boolean;
};


export interface __CompositeMLDsa$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface CompositeMLDsa$instance extends System_Internal.IDisposable$instance {}

export type CompositeMLDsa = CompositeMLDsa$instance & __CompositeMLDsa$views;


export interface CompositeMLDsaAlgorithm$instance {
    readonly MaxSignatureSizeInBytes: int;
    readonly Name: string;
    Equals(other: CompositeMLDsaAlgorithm): boolean;
    Equals(obj: unknown): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const CompositeMLDsaAlgorithm: {
    new(): CompositeMLDsaAlgorithm$instance;
    readonly MLDsa44WithRSA2048Pss: CompositeMLDsaAlgorithm;
    readonly MLDsa44WithRSA2048Pkcs15: CompositeMLDsaAlgorithm;
    readonly MLDsa44WithEd25519: CompositeMLDsaAlgorithm;
    readonly MLDsa44WithECDsaP256: CompositeMLDsaAlgorithm;
    readonly MLDsa65WithRSA3072Pss: CompositeMLDsaAlgorithm;
    readonly MLDsa65WithRSA3072Pkcs15: CompositeMLDsaAlgorithm;
    readonly MLDsa65WithRSA4096Pss: CompositeMLDsaAlgorithm;
    readonly MLDsa65WithRSA4096Pkcs15: CompositeMLDsaAlgorithm;
    readonly MLDsa65WithECDsaP256: CompositeMLDsaAlgorithm;
    readonly MLDsa65WithECDsaP384: CompositeMLDsaAlgorithm;
    readonly MLDsa65WithECDsaBrainpoolP256r1: CompositeMLDsaAlgorithm;
    readonly MLDsa65WithEd25519: CompositeMLDsaAlgorithm;
    readonly MLDsa87WithECDsaP384: CompositeMLDsaAlgorithm;
    readonly MLDsa87WithECDsaBrainpoolP384r1: CompositeMLDsaAlgorithm;
    readonly MLDsa87WithEd448: CompositeMLDsaAlgorithm;
    readonly MLDsa87WithRSA3072Pss: CompositeMLDsaAlgorithm;
    readonly MLDsa87WithRSA4096Pss: CompositeMLDsaAlgorithm;
    readonly MLDsa87WithECDsaP521: CompositeMLDsaAlgorithm;
};


export interface __CompositeMLDsaAlgorithm$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<CompositeMLDsaAlgorithm>;

    // Structural method bridges for numeric interface constraints
    Equals(other: CompositeMLDsaAlgorithm): boolean;
}

export type CompositeMLDsaAlgorithm = CompositeMLDsaAlgorithm$instance & __CompositeMLDsaAlgorithm$views;


export interface CompositeMLDsaCng$instance extends CompositeMLDsa$instance {
    Dispose(): void;
    GetKey(): CngKey;
}


export const CompositeMLDsaCng: {
    new(key: CngKey): CompositeMLDsaCng$instance;
};


export interface __CompositeMLDsaCng$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type CompositeMLDsaCng = CompositeMLDsaCng$instance & __CompositeMLDsaCng$views;


export interface CryptoConfig$instance {
}


export const CryptoConfig: {
    new(): CryptoConfig$instance;
    readonly AllowOnlyFipsAlgorithms: boolean;
    AddAlgorithm(algorithm: Type, names: string[]): void;
    AddOID(oid: string, names: string[]): void;
    CreateFromName(name: string, args: unknown[]): unknown;
    CreateFromName(name: string): unknown;
    EncodeOID(str: string): byte[];
    MapNameToOID(name: string): string;
};


export type CryptoConfig = CryptoConfig$instance;

export interface CryptographicException$instance extends SystemException {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const CryptographicException: {
    new(): CryptographicException$instance;
    new(hr: int): CryptographicException$instance;
    new(message: string): CryptographicException$instance;
    new(message: string, inner: Exception): CryptographicException$instance;
    new(format: string, insert: string): CryptographicException$instance;
};


export interface __CryptographicException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type CryptographicException = CryptographicException$instance & __CryptographicException$views;


export interface CryptographicUnexpectedOperationException$instance extends CryptographicException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const CryptographicUnexpectedOperationException: {
    new(): CryptographicUnexpectedOperationException$instance;
    new(message: string): CryptographicUnexpectedOperationException$instance;
    new(message: string, inner: Exception): CryptographicUnexpectedOperationException$instance;
    new(format: string, insert: string): CryptographicUnexpectedOperationException$instance;
};


export interface __CryptographicUnexpectedOperationException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type CryptographicUnexpectedOperationException = CryptographicUnexpectedOperationException$instance & __CryptographicUnexpectedOperationException$views;


export interface CryptoStream$instance extends Stream {
    readonly CanRead: boolean;
    readonly CanSeek: boolean;
    readonly CanWrite: boolean;
    readonly HasFlushedFinalBlock: boolean;
    readonly Length: long;
    Position: long;
    BeginRead(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    BeginWrite(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    Clear(): void;
    CopyTo(destination: Stream, bufferSize: int): void;
    CopyTo(destination: Stream): void;
    CopyToAsync(destination: Stream, bufferSize: int, cancellationToken: CancellationToken): Task;
    CopyToAsync(destination: Stream): Task;
    CopyToAsync(destination: Stream, bufferSize: int): Task;
    CopyToAsync(destination: Stream, cancellationToken: CancellationToken): Task;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    EndRead(asyncResult: IAsyncResult): int;
    EndWrite(asyncResult: IAsyncResult): void;
    Flush(): void;
    FlushAsync(cancellationToken: CancellationToken): Task;
    FlushAsync(): Task;
    FlushFinalBlock(): void;
    FlushFinalBlockAsync(cancellationToken?: CancellationToken): ValueTask;
    Read(buffer: byte[], offset: int, count: int): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadByte(): int;
    Seek(offset: long, origin: SeekOrigin): long;
    SetLength(value: long): void;
    Write(buffer: byte[], offset: int, count: int): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    WriteAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteAsync(buffer: byte[], offset: int, count: int): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteByte(value: byte): void;
}


export const CryptoStream: {
    new(stream: Stream, transform: ICryptoTransform, mode: CryptoStreamMode): CryptoStream$instance;
    new(stream: Stream, transform: ICryptoTransform, mode: CryptoStreamMode, leaveOpen: boolean): CryptoStream$instance;
};


export interface __CryptoStream$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type CryptoStream = CryptoStream$instance & __CryptoStream$views;


export interface CspKeyContainerInfo$instance {
    readonly Accessible: boolean;
    readonly Exportable: boolean;
    readonly HardwareDevice: boolean;
    readonly KeyContainerName: string;
    readonly KeyNumber: KeyNumber;
    readonly MachineKeyStore: boolean;
    readonly Protected: boolean;
    readonly ProviderName: string;
    readonly ProviderType: int;
    readonly RandomlyGenerated: boolean;
    readonly Removable: boolean;
    readonly UniqueKeyContainerName: string;
}


export const CspKeyContainerInfo: {
    new(parameters: CspParameters): CspKeyContainerInfo$instance;
};


export type CspKeyContainerInfo = CspKeyContainerInfo$instance;

export interface CspParameters$instance {
    ProviderType: int;
    ProviderName: string;
    KeyContainerName: string;
    KeyNumber: int;
    Flags: CspProviderFlags;
    KeyPassword: SecureString;
    ParentWindowHandle: nint;
}


export const CspParameters: {
    new(): CspParameters$instance;
    new(dwTypeIn: int): CspParameters$instance;
    new(dwTypeIn: int, strProviderNameIn: string): CspParameters$instance;
    new(dwTypeIn: int, strProviderNameIn: string, strContainerNameIn: string): CspParameters$instance;
};


export type CspParameters = CspParameters$instance;

export interface DeriveBytes$instance {
    Dispose(): void;
    GetBytes(cb: int): byte[];
    Reset(): void;
}


export const DeriveBytes: {
};


export interface __DeriveBytes$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface DeriveBytes$instance extends System_Internal.IDisposable$instance {}

export type DeriveBytes = DeriveBytes$instance & __DeriveBytes$views;


export interface DES$instance extends SymmetricAlgorithm$instance {
    Key: byte[];
    Dispose(): void;
}


export const DES: {
    IsSemiWeakKey(rgbKey: byte[]): boolean;
    IsWeakKey(rgbKey: byte[]): boolean;
};


export interface __DES$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type DES = DES$instance & __DES$views;


export interface DESCryptoServiceProvider$instance extends DES$instance {
    BlockSize: int;
    FeedbackSize: int;
    IV: byte[];
    Key: byte[];
    KeySize: int;
    readonly LegalBlockSizes: KeySizes[];
    readonly LegalKeySizes: KeySizes[];
    Mode: CipherMode;
    Padding: PaddingMode;
    CreateDecryptor(): ICryptoTransform;
    CreateDecryptor(rgbKey: byte[], rgbIV: byte[]): ICryptoTransform;
    CreateEncryptor(): ICryptoTransform;
    CreateEncryptor(rgbKey: byte[], rgbIV: byte[]): ICryptoTransform;
    Dispose(): void;
    GenerateIV(): void;