// Generated by tsbindgen - Architecture
// Namespace: System.Security.Cryptography.Xml
// Assembly: System.Security.Cryptography.Pkcs, System.Security.Cryptography.Xml

// Core type aliases from @tsonic/core
import type { fnptr, ptr, sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';


// Import types from other namespaces
import type { Collection_1 } from "@tsonic/dotnet/System.Collections.ObjectModel/internal/index.js";
import * as System_Collections_Internal from "@tsonic/dotnet/System.Collections/internal/index.js";
import type { ArrayList, Hashtable, ICollection, IEnumerable, IEnumerator, IList } from "@tsonic/dotnet/System.Collections/internal/index.js";
import type { Stream } from "@tsonic/dotnet/System.IO/internal/index.js";
import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
import type { ISerializable, SerializationInfo, StreamingContext } from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
import type { X509Certificate, X509Certificate2, X509IncludeOption } from "@tsonic/dotnet/System.Security.Cryptography.X509Certificates/internal/index.js";
import type { AsymmetricAlgorithm, CipherMode, DSA, HashAlgorithm, KeyedHashAlgorithm, PaddingMode, RSA, SymmetricAlgorithm } from "@tsonic/dotnet/System.Security.Cryptography/internal/index.js";
import type { Evidence } from "@tsonic/dotnet/System.Security.Policy/internal/index.js";
import type { Encoding } from "@tsonic/dotnet/System.Text/internal/index.js";
import * as System_Xml_Internal from "@tsonic/dotnet/System.Xml/internal/index.js";
import type { XmlDocument, XmlElement, XmlException, XmlNodeList, XmlResolver } from "@tsonic/dotnet/System.Xml/internal/index.js";
import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
import type { Array as ClrArray, Boolean as ClrBoolean, Byte, Exception, Func_2, Int32, Object as ClrObject, String as ClrString, Type, ValueType, Void } from "@tsonic/dotnet/System/internal/index.js";

export interface IRelDecryptor$instance {
    readonly __tsonic_iface_System_Security_Cryptography_Xml_IRelDecryptor: never;

    Decrypt(encryptionMethod: EncryptionMethod, keyInfo: KeyInfo, toDecrypt: Stream): Stream;
}


export type IRelDecryptor = IRelDecryptor$instance;

export interface X509IssuerSerial$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_X509IssuerSerial: never;

    IssuerName: string;
    SerialNumber: string;
}


export const X509IssuerSerial: {
    new(): X509IssuerSerial;
};


export type X509IssuerSerial = X509IssuerSerial$instance;

export interface CipherData$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_CipherData: never;

    get CipherReference(): CipherReference | null;
    set CipherReference(value: CipherReference | null);
    get CipherValue(): byte[] | null;
    set CipherValue(value: byte[] | null);
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const CipherData: {
    new(): CipherData;
    new(cipherValue: byte[]): CipherData;
    new(cipherReference: CipherReference): CipherData;
};


export type CipherData = CipherData$instance;

export interface CipherReference$instance extends EncryptedReference {
    readonly __tsonic_type_System_Security_Cryptography_Xml_CipherReference: never;

    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const CipherReference: {
    new(): CipherReference;
    new(uri: string): CipherReference;
    new(uri: string, transformChain: TransformChain): CipherReference;
};


export type CipherReference = CipherReference$instance;

export interface CryptoSignedXmlRecursionException$instance extends XmlException {
    readonly __tsonic_type_System_Security_Cryptography_Xml_CryptoSignedXmlRecursionException: never;

    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;

}


export const CryptoSignedXmlRecursionException: {
    new(): CryptoSignedXmlRecursionException;
    new(message: string): CryptoSignedXmlRecursionException;
    new(message: string, inner: Exception): CryptoSignedXmlRecursionException;
};


export type CryptoSignedXmlRecursionException = CryptoSignedXmlRecursionException$instance;

export interface DataObject$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_DataObject: never;

    Data: XmlNodeList;
    get Encoding(): string | null;
    set Encoding(value: string | null);
    get Id(): string | null;
    set Id(value: string | null);
    get MimeType(): string | null;
    set MimeType(value: string | null);
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const DataObject: {
    new(): DataObject;
    new(id: string, mimeType: string, encoding: string, data: XmlElement): DataObject;
};


export type DataObject = DataObject$instance;

export interface DataReference$instance extends EncryptedReference {
    readonly __tsonic_type_System_Security_Cryptography_Xml_DataReference: never;

}


export const DataReference: {
    new(): DataReference;
    new(uri: string): DataReference;
    new(uri: string, transformChain: TransformChain): DataReference;
};


export type DataReference = DataReference$instance;

export interface DSAKeyValue$instance extends KeyInfoClause {
    readonly __tsonic_type_System_Security_Cryptography_Xml_DSAKeyValue: never;

    Key: DSA;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const DSAKeyValue: {
    new(): DSAKeyValue;
    new(key: DSA): DSAKeyValue;
};


export type DSAKeyValue = DSAKeyValue$instance;

export interface EncryptedData$instance extends EncryptedType {
    readonly __tsonic_type_System_Security_Cryptography_Xml_EncryptedData: never;

    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const EncryptedData: {
    new(): EncryptedData;
};


export type EncryptedData = EncryptedData$instance;

export interface EncryptedKey$instance extends EncryptedType {
    readonly __tsonic_type_System_Security_Cryptography_Xml_EncryptedKey: never;

    get CarriedKeyName(): string | null;
    set CarriedKeyName(value: string | null);
    Recipient: string;
    readonly ReferenceList: ReferenceList;
    AddReference(dataReference: DataReference): void;
    AddReference(keyReference: KeyReference): void;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const EncryptedKey: {
    new(): EncryptedKey;
};


export type EncryptedKey = EncryptedKey$instance;

export interface EncryptedReference$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_EncryptedReference: never;

    TransformChain: TransformChain;
    Uri: string;
    AddTransform(transform: Transform): void;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const EncryptedReference: (abstract new() => EncryptedReference) & (abstract new(uri: string) => EncryptedReference) & (abstract new(uri: string, transformChain: TransformChain) => EncryptedReference) & {
};


export type EncryptedReference = EncryptedReference$instance;

export interface EncryptedType$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_EncryptedType: never;

    CipherData: CipherData;
    get Encoding(): string | null;
    set Encoding(value: string | null);
    get EncryptionMethod(): EncryptionMethod | null;
    set EncryptionMethod(value: EncryptionMethod | null);
    readonly EncryptionProperties: EncryptionPropertyCollection;
    get Id(): string | null;
    set Id(value: string | null);
    KeyInfo: KeyInfo;
    get MimeType(): string | null;
    set MimeType(value: string | null);
    get Type(): string | null;
    set Type(value: string | null);
    AddProperty(ep: EncryptionProperty): void;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const EncryptedType: (abstract new() => EncryptedType) & {
};


export type EncryptedType = EncryptedType$instance;

export interface EncryptedXml$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_EncryptedXml: never;

    get DocumentEvidence(): Evidence | null;
    set DocumentEvidence(value: Evidence | null);
    Encoding: Encoding;
    Mode: CipherMode;
    Padding: PaddingMode;
    Recipient: string;
    get Resolver(): XmlResolver | null;
    set Resolver(value: XmlResolver | null);
    XmlDSigSearchDepth: int;
    AddKeyNameMapping(keyName: string, keyObject: unknown): void;
    ClearKeyNameMappings(): void;
    DecryptData(encryptedData: EncryptedData, symmetricAlgorithm: SymmetricAlgorithm): byte[];
    DecryptDocument(): void;
    DecryptEncryptedKey(encryptedKey: EncryptedKey): byte[] | null;
    Encrypt(inputElement: XmlElement, certificate: X509Certificate2): EncryptedData;
    Encrypt(inputElement: XmlElement, keyName: string): EncryptedData;
    EncryptData(plaintext: byte[], symmetricAlgorithm: SymmetricAlgorithm): byte[];
    EncryptData(inputElement: XmlElement, symmetricAlgorithm: SymmetricAlgorithm, content: boolean): byte[];
    GetDecryptionIV(encryptedData: EncryptedData, symmetricAlgorithmUri: string | null): byte[];
    GetDecryptionKey(encryptedData: EncryptedData, symmetricAlgorithmUri: string | null): SymmetricAlgorithm | null;
    GetIdElement(document: XmlDocument, idValue: string): XmlElement | null;
    ReplaceData(inputElement: XmlElement, decryptedData: byte[]): void;
}


export const EncryptedXml: {
    new(): EncryptedXml;
    new(document: XmlDocument): EncryptedXml;
    new(document: XmlDocument, evidence: Evidence | null): EncryptedXml;
    readonly XmlEncNamespaceUrl: string;
    readonly XmlEncElementUrl: string;
    readonly XmlEncElementContentUrl: string;
    readonly XmlEncEncryptedKeyUrl: string;
    readonly XmlEncDESUrl: string;
    readonly XmlEncTripleDESUrl: string;
    readonly XmlEncAES128Url: string;
    readonly XmlEncAES256Url: string;
    readonly XmlEncAES192Url: string;
    readonly XmlEncRSA15Url: string;
    readonly XmlEncRSAOAEPUrl: string;
    readonly XmlEncTripleDESKeyWrapUrl: string;
    readonly XmlEncAES128KeyWrapUrl: string;
    readonly XmlEncAES256KeyWrapUrl: string;
    readonly XmlEncAES192KeyWrapUrl: string;
    readonly XmlEncSHA256Url: string;
    readonly XmlEncSHA512Url: string;
    DecryptKey(keyData: byte[], rsa: RSA, useOAEP: boolean): byte[];
    DecryptKey(keyData: byte[], symmetricAlgorithm: SymmetricAlgorithm): byte[];
    EncryptKey(keyData: byte[], rsa: RSA, useOAEP: boolean): byte[];
    EncryptKey(keyData: byte[], symmetricAlgorithm: SymmetricAlgorithm): byte[];
    ReplaceElement(inputElement: XmlElement, encryptedData: EncryptedData, content: boolean): void;
};


export type EncryptedXml = EncryptedXml$instance;

export interface EncryptionMethod$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_EncryptionMethod: never;

    get KeyAlgorithm(): string | null;
    set KeyAlgorithm(value: string | null);
    KeySize: int;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const EncryptionMethod: {
    new(): EncryptionMethod;
    new(algorithm: string | null): EncryptionMethod;
};


export type EncryptionMethod = EncryptionMethod$instance;

export interface EncryptionProperty$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_EncryptionProperty: never;

    readonly Id: string | null;
    get PropertyElement(): XmlElement | null;
    set PropertyElement(value: XmlElement | null);
    readonly Target: string | null;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const EncryptionProperty: {
    new(): EncryptionProperty;
    new(elementProperty: XmlElement): EncryptionProperty;
};


export type EncryptionProperty = EncryptionProperty$instance;

export interface EncryptionPropertyCollection$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_EncryptionPropertyCollection: never;

    readonly __tsonic_iface_System_Collections_ICollection: never;
    readonly __tsonic_iface_System_Collections_IEnumerable: never;
    readonly __tsonic_iface_System_Collections_IList: never;

    readonly Count: int;
    readonly IsFixedSize: boolean;
    readonly IsReadOnly: boolean;
    readonly IsSynchronized: boolean;
    readonly SyncRoot: unknown;
    Add(value: EncryptionProperty): int;
    Clear(): void;
    Contains(value: EncryptionProperty): boolean;
    CopyTo(array: ClrArray, index: int): void;
    CopyTo(array: EncryptionProperty[], index: int): void;
    GetEnumerator(): IEnumerator;
    IndexOf(value: EncryptionProperty): int;
    Insert(index: int, value: EncryptionProperty): void;
    Item(index: int): EncryptionProperty;
    Remove(value: EncryptionProperty): void;
    RemoveAt(index: int): void;
}


export const EncryptionPropertyCollection: {
    new(): EncryptionPropertyCollection;
};


export type EncryptionPropertyCollection = EncryptionPropertyCollection$instance & { [index: number]: EncryptionProperty; };

export interface KeyInfo$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_KeyInfo: never;

    readonly __tsonic_iface_System_Collections_IEnumerable: never;

    readonly Count: int;
    get Id(): string | null;
    set Id(value: string | null);
    AddClause(clause: KeyInfoClause): void;
    GetEnumerator(): IEnumerator;
    GetEnumerator(requestedObjectType: Type): IEnumerator;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const KeyInfo: {
    new(): KeyInfo;
};


export type KeyInfo = KeyInfo$instance;

export interface KeyInfoClause$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_KeyInfoClause: never;

    GetXml(): XmlElement;
    LoadXml(element: XmlElement): void;
}


export const KeyInfoClause: (abstract new() => KeyInfoClause) & {
};


export type KeyInfoClause = KeyInfoClause$instance;

export interface KeyInfoEncryptedKey$instance extends KeyInfoClause {
    readonly __tsonic_type_System_Security_Cryptography_Xml_KeyInfoEncryptedKey: never;

    get EncryptedKey(): EncryptedKey | null;
    set EncryptedKey(value: EncryptedKey | null);
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const KeyInfoEncryptedKey: {
    new(): KeyInfoEncryptedKey;
    new(encryptedKey: EncryptedKey): KeyInfoEncryptedKey;
};


export type KeyInfoEncryptedKey = KeyInfoEncryptedKey$instance;

export interface KeyInfoName$instance extends KeyInfoClause {
    readonly __tsonic_type_System_Security_Cryptography_Xml_KeyInfoName: never;

    get Value(): string | null;
    set Value(value: string | null);
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const KeyInfoName: {
    new(): KeyInfoName;
    new(keyName: string | null): KeyInfoName;
};


export type KeyInfoName = KeyInfoName$instance;

export interface KeyInfoNode$instance extends KeyInfoClause {
    readonly __tsonic_type_System_Security_Cryptography_Xml_KeyInfoNode: never;

    get Value(): XmlElement | null;
    set Value(value: XmlElement | null);
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const KeyInfoNode: {
    new(): KeyInfoNode;
    new(node: XmlElement): KeyInfoNode;
};


export type KeyInfoNode = KeyInfoNode$instance;

export interface KeyInfoRetrievalMethod$instance extends KeyInfoClause {
    readonly __tsonic_type_System_Security_Cryptography_Xml_KeyInfoRetrievalMethod: never;

    get Type(): string | null;
    set Type(value: string | null);
    get Uri(): string | null;
    set Uri(value: string | null);
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const KeyInfoRetrievalMethod: {
    new(): KeyInfoRetrievalMethod;
    new(strUri: string | null): KeyInfoRetrievalMethod;
    new(strUri: string, typeName: string): KeyInfoRetrievalMethod;
};


export type KeyInfoRetrievalMethod = KeyInfoRetrievalMethod$instance;

export interface KeyInfoX509Data$instance extends KeyInfoClause {
    readonly __tsonic_type_System_Security_Cryptography_Xml_KeyInfoX509Data: never;

    readonly Certificates: ArrayList | null;
    get CRL(): byte[] | null;
    set CRL(value: byte[] | null);
    readonly IssuerSerials: ArrayList | null;
    readonly SubjectKeyIds: ArrayList | null;
    readonly SubjectNames: ArrayList | null;
    AddCertificate(certificate: X509Certificate): void;
    AddIssuerSerial(issuerName: string, serialNumber: string): void;
    AddSubjectKeyId(subjectKeyId: byte[]): void;
    AddSubjectKeyId(subjectKeyId: string): void;
    AddSubjectName(subjectName: string): void;
    GetXml(): XmlElement;
    LoadXml(element: XmlElement): void;
}


export const KeyInfoX509Data: {
    new(): KeyInfoX509Data;
    new(rgbCert: byte[]): KeyInfoX509Data;
    new(cert: X509Certificate): KeyInfoX509Data;
    new(cert: X509Certificate, includeOption: X509IncludeOption): KeyInfoX509Data;
};


export type KeyInfoX509Data = KeyInfoX509Data$instance;

export interface KeyReference$instance extends EncryptedReference {
    readonly __tsonic_type_System_Security_Cryptography_Xml_KeyReference: never;

}


export const KeyReference: {
    new(): KeyReference;
    new(uri: string): KeyReference;
    new(uri: string, transformChain: TransformChain): KeyReference;
};


export type KeyReference = KeyReference$instance;

export interface Reference$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_Reference: never;

    DigestMethod: string;
    get DigestValue(): byte[] | null;
    set DigestValue(value: byte[] | null);
    get Id(): string | null;
    set Id(value: string | null);
    TransformChain: TransformChain;
    get Type(): string | null;
    set Type(value: string | null);
    get Uri(): string | null;
    set Uri(value: string | null);
    AddTransform(transform: Transform): void;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const Reference: {
    new(): Reference;
    new(stream: Stream): Reference;
    new(uri: string | null): Reference;
};


export type Reference = Reference$instance;

export interface ReferenceList$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_ReferenceList: never;

    readonly __tsonic_iface_System_Collections_ICollection: never;
    readonly __tsonic_iface_System_Collections_IEnumerable: never;
    readonly __tsonic_iface_System_Collections_IList: never;

    readonly Count: int;
    readonly IsSynchronized: boolean;
    readonly SyncRoot: unknown;
    Add(value: unknown | null): int;
    Clear(): void;
    Contains(value: unknown | null): boolean;
    CopyTo(array: ClrArray, index: int): void;
    GetEnumerator(): IEnumerator;
    IndexOf(value: unknown | null): int;
    Insert(index: int, value: unknown | null): void;
    Item(index: int): EncryptedReference | null;
    Remove(value: unknown | null): void;
    RemoveAt(index: int): void;
}


export const ReferenceList: {
    new(): ReferenceList;
};


export type ReferenceList = ReferenceList$instance & { [index: number]: EncryptedReference; };

export interface RSAKeyValue$instance extends KeyInfoClause {
    readonly __tsonic_type_System_Security_Cryptography_Xml_RSAKeyValue: never;

    Key: RSA;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const RSAKeyValue: {
    new(): RSAKeyValue;
    new(key: RSA): RSAKeyValue;
};


export type RSAKeyValue = RSAKeyValue$instance;

export interface Signature$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_Signature: never;

    get Id(): string | null;
    set Id(value: string | null);
    KeyInfo: KeyInfo;
    ObjectList: IList;
    get SignatureValue(): byte[] | null;
    set SignatureValue(value: byte[] | null);
    get SignedInfo(): SignedInfo | null;
    set SignedInfo(value: SignedInfo | null);
    AddObject(dataObject: DataObject): void;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const Signature: {
    new(): Signature;
};


export type Signature = Signature$instance;

export interface SignedInfo$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_SignedInfo: never;

    readonly __tsonic_iface_System_Collections_ICollection: never;
    readonly __tsonic_iface_System_Collections_IEnumerable: never;

    CanonicalizationMethod: string;
    readonly CanonicalizationMethodObject: Transform;
    readonly Count: int;
    get Id(): string | null;
    set Id(value: string | null);
    readonly IsReadOnly: boolean;
    readonly IsSynchronized: boolean;
    readonly References: ArrayList;
    get SignatureLength(): string | null;
    set SignatureLength(value: string | null);
    get SignatureMethod(): string | null;
    set SignatureMethod(value: string | null);
    readonly SyncRoot: unknown;
    AddReference(reference: Reference): void;
    CopyTo(array: ClrArray, index: int): void;
    GetEnumerator(): IEnumerator;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const SignedInfo: {
    new(): SignedInfo;
};


export type SignedInfo = SignedInfo$instance;

export interface SignedXml$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_SignedXml: never;

    EncryptedXml: EncryptedXml;
    KeyInfo: KeyInfo;
    Resolver: XmlResolver;
    readonly SafeCanonicalizationMethods: Collection_1<System_Internal.String>;
    readonly Signature: Signature;
    SignatureFormatValidator: Func_2<SignedXml, System_Internal.Boolean>;
    readonly SignatureLength: string | null;
    readonly SignatureMethod: string | null;
    readonly SignatureValue: byte[] | null;
    readonly SignedInfo: SignedInfo | null;
    get SigningKey(): AsymmetricAlgorithm | null;
    set SigningKey(value: AsymmetricAlgorithm | null);
    get SigningKeyName(): string | null;
    set SigningKeyName(value: string | null);
    AddObject(dataObject: DataObject): void;
    AddReference(reference: Reference): void;
    CheckSignature(): boolean;
    CheckSignature(key: AsymmetricAlgorithm): boolean;
    CheckSignature(macAlg: KeyedHashAlgorithm): boolean;
    CheckSignature(certificate: X509Certificate2, verifySignatureOnly: boolean): boolean;
    CheckSignatureReturningKey(signingKey: AsymmetricAlgorithm | null): boolean;
    ComputeSignature(): void;
    ComputeSignature(macAlg: KeyedHashAlgorithm): void;
    GetIdElement(document: XmlDocument | null, idValue: string): XmlElement | null;
    GetPublicKey(): AsymmetricAlgorithm | null;
    GetXml(): XmlElement;
    LoadXml(value: XmlElement): void;
}


export const SignedXml: {
    new(): SignedXml;
    new(document: XmlDocument): SignedXml;
    new(elem: XmlElement): SignedXml;
    readonly XmlDsigNamespaceUrl: string;
    readonly XmlDsigMinimalCanonicalizationUrl: string;
    readonly XmlDsigCanonicalizationUrl: string;
    readonly XmlDsigCanonicalizationWithCommentsUrl: string;
    readonly XmlDsigSHA1Url: string;
    readonly XmlDsigDSAUrl: string;
    readonly XmlDsigRSASHA1Url: string;
    readonly XmlDsigHMACSHA1Url: string;
    readonly XmlDsigSHA256Url: string;
    readonly XmlDsigRSASHA256Url: string;
    readonly XmlDsigSHA384Url: string;
    readonly XmlDsigRSASHA384Url: string;
    readonly XmlDsigSHA512Url: string;
    readonly XmlDsigRSASHA512Url: string;
    readonly XmlDsigC14NTransformUrl: string;
    readonly XmlDsigC14NWithCommentsTransformUrl: string;
    readonly XmlDsigExcC14NTransformUrl: string;
    readonly XmlDsigExcC14NWithCommentsTransformUrl: string;
    readonly XmlDsigBase64TransformUrl: string;
    readonly XmlDsigXPathTransformUrl: string;
    readonly XmlDsigXsltTransformUrl: string;
    readonly XmlDsigEnvelopedSignatureTransformUrl: string;
    readonly XmlDecryptionTransformUrl: string;
    readonly XmlLicenseTransformUrl: string;
};


export type SignedXml = SignedXml$instance;

export interface Transform$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_Transform: never;

    get Algorithm(): string | null;
    set Algorithm(value: string | null);
    get Context(): XmlElement | null;
    set Context(value: XmlElement | null);
    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    readonly PropagatedNamespaces: Hashtable;
    GetDigestedOutput(hash: HashAlgorithm): byte[];
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    GetXml(): XmlElement;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const Transform: (abstract new() => Transform) & {
};


export type Transform = Transform$instance;

export interface TransformChain$instance {
    readonly __tsonic_type_System_Security_Cryptography_Xml_TransformChain: never;

    readonly Count: int;
    Add(transform: Transform): void;
    GetEnumerator(): IEnumerator;
}


export const TransformChain: {
    new(): TransformChain;
};


export type TransformChain = TransformChain$instance & { readonly [index: number]: Transform; };

export interface XmlDecryptionTransform$instance extends Transform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDecryptionTransform: never;

    EncryptedXml: EncryptedXml;
    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    AddExceptUri(uri: string): void;
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    IsTargetElement(inputElement: XmlElement | null, idValue: string): boolean;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const XmlDecryptionTransform: {
    new(): XmlDecryptionTransform;
};


export type XmlDecryptionTransform = XmlDecryptionTransform$instance;

export interface XmlDsigBase64Transform$instance extends Transform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDsigBase64Transform: never;

    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const XmlDsigBase64Transform: {
    new(): XmlDsigBase64Transform;
};


export type XmlDsigBase64Transform = XmlDsigBase64Transform$instance;

export interface XmlDsigC14NTransform$instance extends Transform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDsigC14NTransform: never;

    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    GetDigestedOutput(hash: HashAlgorithm): byte[];
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const XmlDsigC14NTransform: {
    new(): XmlDsigC14NTransform;
    new(includeComments: boolean): XmlDsigC14NTransform;
};


export type XmlDsigC14NTransform = XmlDsigC14NTransform$instance;

export interface XmlDsigC14NWithCommentsTransform$instance extends XmlDsigC14NTransform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDsigC14NWithCommentsTransform: never;

}


export const XmlDsigC14NWithCommentsTransform: {
    new(): XmlDsigC14NWithCommentsTransform;
};


export type XmlDsigC14NWithCommentsTransform = XmlDsigC14NWithCommentsTransform$instance;

export interface XmlDsigEnvelopedSignatureTransform$instance extends Transform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDsigEnvelopedSignatureTransform: never;

    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const XmlDsigEnvelopedSignatureTransform: {
    new(): XmlDsigEnvelopedSignatureTransform;
    new(includeComments: boolean): XmlDsigEnvelopedSignatureTransform;
};


export type XmlDsigEnvelopedSignatureTransform = XmlDsigEnvelopedSignatureTransform$instance;

export interface XmlDsigExcC14NTransform$instance extends Transform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDsigExcC14NTransform: never;

    get InclusiveNamespacesPrefixList(): string | null;
    set InclusiveNamespacesPrefixList(value: string | null);
    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    GetDigestedOutput(hash: HashAlgorithm): byte[];
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const XmlDsigExcC14NTransform: {
    new(): XmlDsigExcC14NTransform;
    new(includeComments: boolean): XmlDsigExcC14NTransform;
    new(inclusiveNamespacesPrefixList: string): XmlDsigExcC14NTransform;
    new(includeComments: boolean, inclusiveNamespacesPrefixList: string | null): XmlDsigExcC14NTransform;
};


export type XmlDsigExcC14NTransform = XmlDsigExcC14NTransform$instance;

export interface XmlDsigExcC14NWithCommentsTransform$instance extends XmlDsigExcC14NTransform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDsigExcC14NWithCommentsTransform: never;

}


export const XmlDsigExcC14NWithCommentsTransform: {
    new(): XmlDsigExcC14NWithCommentsTransform;
    new(inclusiveNamespacesPrefixList: string): XmlDsigExcC14NWithCommentsTransform;
};


export type XmlDsigExcC14NWithCommentsTransform = XmlDsigExcC14NWithCommentsTransform$instance;

export interface XmlDsigXPathTransform$instance extends Transform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDsigXPathTransform: never;

    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const XmlDsigXPathTransform: {
    new(): XmlDsigXPathTransform;
};


export type XmlDsigXPathTransform = XmlDsigXPathTransform$instance;

export interface XmlDsigXsltTransform$instance extends Transform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlDsigXsltTransform: never;

    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const XmlDsigXsltTransform: {
    new(): XmlDsigXsltTransform;
    new(includeComments: boolean): XmlDsigXsltTransform;
};


export type XmlDsigXsltTransform = XmlDsigXsltTransform$instance;

export interface XmlLicenseTransform$instance extends Transform {
    readonly __tsonic_type_System_Security_Cryptography_Xml_XmlLicenseTransform: never;

    get Decryptor(): IRelDecryptor | null;
    set Decryptor(value: IRelDecryptor | null);
    readonly InputTypes: Type[];
    readonly OutputTypes: Type[];
    GetInnerXml(): XmlNodeList | null;
    GetOutput(): unknown;
    GetOutput(type: Type): unknown;
    LoadInnerXml(nodeList: XmlNodeList): void;
    LoadInput(obj: unknown): void;
}


export const XmlLicenseTransform: {
    new(): XmlLicenseTransform;
};


export type XmlLicenseTransform = XmlLicenseTransform$instance;