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

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

// 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(): vo