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

// 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 { CryptographicAttributeObject, CryptographicAttributeObjectCollection } from "../../System.Security.Cryptography/internal/index.js";
import type { IEnumerable_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
import type { ReadOnlyCollection_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 { ICollection, IEnumerable, IEnumerator } from "@tsonic/dotnet/System.Collections/internal/index.js";
import type { X509Certificate2, X509Certificate2Collection, X509ExtensionCollection, X509IncludeOption } from "@tsonic/dotnet/System.Security.Cryptography.X509Certificates/internal/index.js";
import * as System_Security_Cryptography_Lib_tsonic_dotnet from "@tsonic/dotnet/System.Security.Cryptography/internal/index.js";
import type { AsnEncodedData, AsymmetricAlgorithm, CompositeMLDsa, CspParameters, HashAlgorithmName, MLDsa, Oid, PbeParameters, RSA, RSAEncryptionPadding, RSASignaturePadding, SlhDsa } from "@tsonic/dotnet/System.Security.Cryptography/internal/index.js";
import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
import type { Array as ClrArray, Boolean as ClrBoolean, Byte, Char, DateTime, DateTimeOffset, Enum, IComparable, IConvertible, IFormattable, Int32, Int64, ISpanFormattable, Nullable_1, Object as ClrObject, ReadOnlyMemory_1, ReadOnlySpan_1, Span_1, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";

export enum Pkcs12ConfidentialityMode {
    Unknown = 0,
    None = 1,
    Password = 2,
    PublicKey = 3
}


export enum Pkcs12IntegrityMode {
    Unknown = 0,
    None = 1,
    Password = 2,
    PublicKey = 3
}


export enum RecipientInfoType {
    Unknown = 0,
    KeyTransport = 1,
    KeyAgreement = 2
}


export enum SubjectIdentifierOrKeyType {
    Unknown = 0,
    IssuerAndSerialNumber = 1,
    SubjectKeyIdentifier = 2,
    PublicKeyInfo = 3
}


export enum SubjectIdentifierType {
    Unknown = 0,
    IssuerAndSerialNumber = 1,
    SubjectKeyIdentifier = 2,
    NoSignature = 3
}


export interface AlgorithmIdentifier$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_AlgorithmIdentifier: never;

    KeyLength: int;
    Oid: Oid;
    Parameters: byte[];
}


export const AlgorithmIdentifier: {
    new(): AlgorithmIdentifier;
    new(oid: Oid): AlgorithmIdentifier;
    new(oid: Oid, keyLength: int): AlgorithmIdentifier;
};


export type AlgorithmIdentifier = AlgorithmIdentifier$instance;

export interface CmsRecipient$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_CmsRecipient: never;

    readonly Certificate: X509Certificate2;
    readonly RecipientIdentifierType: SubjectIdentifierType;
    readonly RSAEncryptionPadding: RSAEncryptionPadding | null;
}


export const CmsRecipient: {
    new(certificate: X509Certificate2): CmsRecipient;
    new(certificate: X509Certificate2, rsaEncryptionPadding: RSAEncryptionPadding): CmsRecipient;
    new(recipientIdentifierType: SubjectIdentifierType, certificate: X509Certificate2, rsaEncryptionPadding: RSAEncryptionPadding): CmsRecipient;
    new(recipientIdentifierType: SubjectIdentifierType, certificate: X509Certificate2): CmsRecipient;
};


export type CmsRecipient = CmsRecipient$instance;

export interface CmsRecipientCollection$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_CmsRecipientCollection: never;

    readonly __tsonic_iface_System_Collections_ICollection: never;
    readonly __tsonic_iface_System_Collections_IEnumerable: never;

    readonly Count: int;
    readonly IsSynchronized: boolean;
    readonly SyncRoot: unknown;
    Add(recipient: CmsRecipient): int;
    CopyTo(array: ClrArray, index: int): void;
    CopyTo(array: CmsRecipient[], index: int): void;
    GetEnumerator(): CmsRecipientEnumerator;
    Remove(recipient: CmsRecipient): void;
}


export const CmsRecipientCollection: {
    new(): CmsRecipientCollection;
    new(recipient: CmsRecipient): CmsRecipientCollection;
    new(recipientIdentifierType: SubjectIdentifierType, certificates: X509Certificate2Collection): CmsRecipientCollection;
};


export type CmsRecipientCollection = CmsRecipientCollection$instance & { readonly [index: number]: CmsRecipient; };

export interface CmsRecipientEnumerator$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_CmsRecipientEnumerator: never;

    readonly __tsonic_iface_System_Collections_IEnumerator: never;

    readonly Current: CmsRecipient;
    MoveNext(): boolean;
    Reset(): void;
}


export const CmsRecipientEnumerator: {
};


export type CmsRecipientEnumerator = CmsRecipientEnumerator$instance;

export interface CmsSigner$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_CmsSigner: never;

    get Certificate(): X509Certificate2 | null;
    set Certificate(value: X509Certificate2 | null);
    readonly Certificates: X509Certificate2Collection;
    DigestAlgorithm: Oid;
    IncludeOption: X509IncludeOption;
    get PrivateKey(): AsymmetricAlgorithm | null;
    set PrivateKey(value: AsymmetricAlgorithm | null);
    get SignaturePadding(): RSASignaturePadding | null;
    set SignaturePadding(value: RSASignaturePadding | null);
    readonly SignedAttributes: CryptographicAttributeObjectCollection;
    SignerIdentifierType: SubjectIdentifierType;
    readonly UnsignedAttributes: CryptographicAttributeObjectCollection;
}


export const CmsSigner: {
    new(): CmsSigner;
    new(signerIdentifierType: SubjectIdentifierType): CmsSigner;
    new(certificate: X509Certificate2 | null): CmsSigner;
    new(parameters: CspParameters): CmsSigner;
    new(signerIdentifierType: SubjectIdentifierType, certificate: X509Certificate2 | null): CmsSigner;
    new(signerIdentifierType: SubjectIdentifierType, certificate: X509Certificate2 | null, privateKey: AsymmetricAlgorithm | null): CmsSigner;
    new(signerIdentifierType: SubjectIdentifierType, certificate: X509Certificate2 | null, privateKey: MLDsa | null): CmsSigner;
    new(signerIdentifierType: SubjectIdentifierType, certificate: X509Certificate2 | null, privateKey: SlhDsa | null): CmsSigner;
    new(signerIdentifierType: SubjectIdentifierType, certificate: X509Certificate2 | null, privateKey: CompositeMLDsa | null): CmsSigner;
    new(signerIdentifierType: SubjectIdentifierType, certificate: X509Certificate2 | null, privateKey: RSA | null, signaturePadding: RSASignaturePadding | null): CmsSigner;
};


export type CmsSigner = CmsSigner$instance;

export interface ContentInfo$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_ContentInfo: never;

    readonly Content: byte[];
    readonly ContentType: Oid;
}


export const ContentInfo: {
    new(content: byte[]): ContentInfo;
    new(contentType: Oid, content: byte[]): ContentInfo;
    GetContentType(encodedMessage: byte[]): Oid;
    GetContentType(encodedMessage: ReadOnlySpan_1<System_Internal.Byte>): Oid;
};


export type ContentInfo = ContentInfo$instance;

export interface EnvelopedCms$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_EnvelopedCms: never;

    Certificates: X509Certificate2Collection;
    ContentEncryptionAlgorithm: AlgorithmIdentifier;
    ContentInfo: ContentInfo;
    readonly RecipientInfos: RecipientInfoCollection;
    UnprotectedAttributes: CryptographicAttributeObjectCollection;
    Version: int;
    Decode(encodedMessage: byte[]): void;
    Decode(encodedMessage: ReadOnlySpan_1<System_Internal.Byte>): void;
    Decrypt(): void;
    Decrypt(recipientInfo: RecipientInfo): void;
    Decrypt(recipientInfo: RecipientInfo, extraStore: X509Certificate2Collection): void;
    Decrypt(extraStore: X509Certificate2Collection): void;
    Decrypt(recipientInfo: RecipientInfo, privateKey: AsymmetricAlgorithm | null): void;
    Encode(): byte[];
    Encrypt(recipient: CmsRecipient): void;
    Encrypt(recipients: CmsRecipientCollection): void;
}


export const EnvelopedCms: {
    new(): EnvelopedCms;
    new(contentInfo: ContentInfo): EnvelopedCms;
    new(contentInfo: ContentInfo, encryptionAlgorithm: AlgorithmIdentifier): EnvelopedCms;
};


export type EnvelopedCms = EnvelopedCms$instance;

export interface KeyAgreeRecipientInfo$instance extends RecipientInfo {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_KeyAgreeRecipientInfo: never;

    readonly Date: DateTime;
    readonly EncryptedKey: byte[];
    readonly KeyEncryptionAlgorithm: AlgorithmIdentifier;
    readonly OriginatorIdentifierOrKey: SubjectIdentifierOrKey;
    readonly OtherKeyAttribute: CryptographicAttributeObject | null;
    readonly RecipientIdentifier: SubjectIdentifier;
    readonly Version: int;
}


export const KeyAgreeRecipientInfo: {
};


export type KeyAgreeRecipientInfo = KeyAgreeRecipientInfo$instance;

export interface KeyTransRecipientInfo$instance extends RecipientInfo {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_KeyTransRecipientInfo: never;

    readonly EncryptedKey: byte[];
    readonly KeyEncryptionAlgorithm: AlgorithmIdentifier;
    readonly RecipientIdentifier: SubjectIdentifier;
    readonly Version: int;
}


export const KeyTransRecipientInfo: {
};


export type KeyTransRecipientInfo = KeyTransRecipientInfo$instance;

export interface Pkcs12Builder$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12Builder: never;

    readonly IsSealed: boolean;
    AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, passwordBytes: byte[] | null, pbeParameters: PbeParameters): void;
    AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, passwordBytes: ReadOnlySpan_1<System_Internal.Byte>, pbeParameters: PbeParameters): void;
    AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, password: string | null, pbeParameters: PbeParameters): void;
    AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, password: ReadOnlySpan_1<System_Internal.Char>, pbeParameters: PbeParameters): void;
    AddSafeContentsUnencrypted(safeContents: Pkcs12SafeContents): void;
    Encode(): byte[];
    SealWithMac(password: string | null, hashAlgorithm: HashAlgorithmName, iterationCount: int): void;
    SealWithMac(password: ReadOnlySpan_1<System_Internal.Char>, hashAlgorithm: HashAlgorithmName, iterationCount: int): void;
    SealWithoutIntegrity(): void;
    TryEncode(destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
}


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


export type Pkcs12Builder = Pkcs12Builder$instance;

export interface Pkcs12CertBag$instance extends Pkcs12SafeBag {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12CertBag: never;

    readonly EncodedCertificate: ReadOnlyMemory_1<System_Internal.Byte>;
    readonly IsX509Certificate: boolean;
    GetCertificate(): X509Certificate2;
    GetCertificateType(): Oid;
}


export const Pkcs12CertBag: {
    new(certificateType: Oid, encodedCertificate: ReadOnlyMemory_1<System_Internal.Byte>): Pkcs12CertBag;
};


export type Pkcs12CertBag = Pkcs12CertBag$instance;

export interface Pkcs12Info$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12Info: never;

    AuthenticatedSafe: ReadOnlyCollection_1<Pkcs12SafeContents>;
    IntegrityMode: Pkcs12IntegrityMode;
    VerifyMac(password: string | null): boolean;
    VerifyMac(password: ReadOnlySpan_1<System_Internal.Char>): boolean;
}


export const Pkcs12Info: {
    Decode(encodedBytes: ReadOnlyMemory_1<System_Internal.Byte>, bytesConsumed: int, skipCopy?: boolean): Pkcs12Info;
};


export type Pkcs12Info = Pkcs12Info$instance;

export interface Pkcs12KeyBag$instance extends Pkcs12SafeBag {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12KeyBag: never;

    readonly Pkcs8PrivateKey: ReadOnlyMemory_1<System_Internal.Byte>;
}


export const Pkcs12KeyBag: {
    new(pkcs8PrivateKey: ReadOnlyMemory_1<System_Internal.Byte>, skipCopy: boolean): Pkcs12KeyBag;
};


export type Pkcs12KeyBag = Pkcs12KeyBag$instance;

export interface Pkcs12SafeBag$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12SafeBag: never;

    Attributes: CryptographicAttributeObjectCollection;
    readonly EncodedBagValue: ReadOnlyMemory_1<System_Internal.Byte>;
    Encode(): byte[];
    GetBagId(): Oid;
    TryEncode(destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
}


export const Pkcs12SafeBag: (abstract new(bagIdValue: string, encodedBagValue: ReadOnlyMemory_1<System_Internal.Byte>, skipCopy: boolean) => Pkcs12SafeBag) & {
};


export type Pkcs12SafeBag = Pkcs12SafeBag$instance;

export interface Pkcs12SafeContents$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12SafeContents: never;

    ConfidentialityMode: Pkcs12ConfidentialityMode;
    readonly IsReadOnly: boolean;
    AddCertificate(certificate: X509Certificate2): Pkcs12CertBag;
    AddKeyUnencrypted(key: AsymmetricAlgorithm): Pkcs12KeyBag;
    AddNestedContents(safeContents: Pkcs12SafeContents): Pkcs12SafeContentsBag;
    AddSafeBag(safeBag: Pkcs12SafeBag): void;
    AddSecret(secretType: Oid, secretValue: ReadOnlyMemory_1<System_Internal.Byte>): Pkcs12SecretBag;
    AddShroudedKey(key: AsymmetricAlgorithm, passwordBytes: byte[] | null, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
    AddShroudedKey(key: AsymmetricAlgorithm, passwordBytes: ReadOnlySpan_1<System_Internal.Byte>, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
    AddShroudedKey(key: AsymmetricAlgorithm, password: string | null, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
    AddShroudedKey(key: AsymmetricAlgorithm, password: ReadOnlySpan_1<System_Internal.Char>, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
    Decrypt(passwordBytes: byte[] | null): void;
    Decrypt(passwordBytes: ReadOnlySpan_1<System_Internal.Byte>): void;
    Decrypt(password: string | null): void;
    Decrypt(password: ReadOnlySpan_1<System_Internal.Char>): void;
    GetBags(): IEnumerable_1<Pkcs12SafeBag>;
}


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


export type Pkcs12SafeContents = Pkcs12SafeContents$instance;

export interface Pkcs12SafeContentsBag$instance extends Pkcs12SafeBag {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12SafeContentsBag: never;

    get SafeContents(): Pkcs12SafeContents | null;
    set SafeContents(value: Pkcs12SafeContents | null);
}


export const Pkcs12SafeContentsBag: {
};


export type Pkcs12SafeContentsBag = Pkcs12SafeContentsBag$instance;

export interface Pkcs12SecretBag$instance extends Pkcs12SafeBag {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12SecretBag: never;

    readonly SecretValue: ReadOnlyMemory_1<System_Internal.Byte>;
    GetSecretType(): Oid;
}


export const Pkcs12SecretBag: {
};


export type Pkcs12SecretBag = Pkcs12SecretBag$instance;

export interface Pkcs12ShroudedKeyBag$instance extends Pkcs12SafeBag {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12ShroudedKeyBag: never;

    readonly EncryptedPkcs8PrivateKey: ReadOnlyMemory_1<System_Internal.Byte>;
}


export const Pkcs12ShroudedKeyBag: {
    new(encryptedPkcs8PrivateKey: ReadOnlyMemory_1<System_Internal.Byte>, skipCopy: boolean): Pkcs12ShroudedKeyBag;
};


export type Pkcs12ShroudedKeyBag = Pkcs12ShroudedKeyBag$instance;

export interface Pkcs8PrivateKeyInfo$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs8PrivateKeyInfo: never;

    readonly AlgorithmId: Oid;
    readonly AlgorithmParameters: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>;
    readonly Attributes: CryptographicAttributeObjectCollection;
    readonly PrivateKeyBytes: ReadOnlyMemory_1<System_Internal.Byte>;
    Encode(): byte[];
    Encrypt(password: ReadOnlySpan_1<System_Internal.Char>, pbeParameters: PbeParameters): byte[];
    Encrypt(passwordBytes: ReadOnlySpan_1<System_Internal.Byte>, pbeParameters: PbeParameters): byte[];
    TryEncode(destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
    TryEncrypt(password: ReadOnlySpan_1<System_Internal.Char>, pbeParameters: PbeParameters, destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
    TryEncrypt(passwordBytes: ReadOnlySpan_1<System_Internal.Byte>, pbeParameters: PbeParameters, destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
}


export const Pkcs8PrivateKeyInfo: {
    new(algorithmId: Oid, algorithmParameters: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, privateKey: ReadOnlyMemory_1<System_Internal.Byte>, skipCopies: boolean): Pkcs8PrivateKeyInfo;
    Create(privateKey: AsymmetricAlgorithm): Pkcs8PrivateKeyInfo;
    Decode(source: ReadOnlyMemory_1<System_Internal.Byte>, bytesRead: int, skipCopy?: boolean): Pkcs8PrivateKeyInfo;
    DecryptAndDecode(passwordBytes: ReadOnlySpan_1<System_Internal.Byte>, source: ReadOnlyMemory_1<System_Internal.Byte>, bytesRead: int): Pkcs8PrivateKeyInfo;
    DecryptAndDecode(password: ReadOnlySpan_1<System_Internal.Char>, source: ReadOnlyMemory_1<System_Internal.Byte>, bytesRead: int): Pkcs8PrivateKeyInfo;
};


export type Pkcs8PrivateKeyInfo = Pkcs8PrivateKeyInfo$instance;

export interface Pkcs9AttributeObject$instance extends AsnEncodedData {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs9AttributeObject: never;

    readonly Oid: Oid | null;
    CopyFrom(asnEncodedData: AsnEncodedData): void;
}


export const Pkcs9AttributeObject: {
    new(): Pkcs9AttributeObject;
    new(oid: string, encodedData: byte[]): Pkcs9AttributeObject;
    new(oid: Oid, encodedData: byte[]): Pkcs9AttributeObject;
    new(asnEncodedData: AsnEncodedData): Pkcs9AttributeObject;
};


export type Pkcs9AttributeObject = Pkcs9AttributeObject$instance;

export interface Pkcs9ContentType$instance extends Pkcs9AttributeObject {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs9ContentType: never;

    readonly ContentType: Oid;
    CopyFrom(asnEncodedData: AsnEncodedData): void;
}


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


export type Pkcs9ContentType = Pkcs9ContentType$instance;

export interface Pkcs9DocumentDescription$instance extends Pkcs9AttributeObject {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs9DocumentDescription: never;

    readonly DocumentDescription: string;
    CopyFrom(asnEncodedData: AsnEncodedData): void;
}


export const Pkcs9DocumentDescription: {
    new(): Pkcs9DocumentDescription;
    new(documentDescription: string): Pkcs9DocumentDescription;
    new(encodedDocumentDescription: byte[]): Pkcs9DocumentDescription;
};


export type Pkcs9DocumentDescription = Pkcs9DocumentDescription$instance;

export interface Pkcs9DocumentName$instance extends Pkcs9AttributeObject {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs9DocumentName: never;

    readonly DocumentName: string;
    CopyFrom(asnEncodedData: AsnEncodedData): void;
}


export const Pkcs9DocumentName: {
    new(): Pkcs9DocumentName;
    new(documentName: string): Pkcs9DocumentName;
    new(encodedDocumentName: byte[]): Pkcs9DocumentName;
};


export type Pkcs9DocumentName = Pkcs9DocumentName$instance;

export interface Pkcs9LocalKeyId$instance extends Pkcs9AttributeObject {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs9LocalKeyId: never;

    readonly KeyId: ReadOnlyMemory_1<System_Internal.Byte>;
    CopyFrom(asnEncodedData: AsnEncodedData): void;
}


export const Pkcs9LocalKeyId: {
    new(): Pkcs9LocalKeyId;
    new(keyId: byte[]): Pkcs9LocalKeyId;
    new(keyId: ReadOnlySpan_1<System_Internal.Byte>): Pkcs9LocalKeyId;
};


export type Pkcs9LocalKeyId = Pkcs9LocalKeyId$instance;

export interface Pkcs9MessageDigest$instance extends Pkcs9AttributeObject {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs9MessageDigest: never;

    readonly MessageDigest: byte[];
    CopyFrom(asnEncodedData: AsnEncodedData): void;
}


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


export type Pkcs9MessageDigest = Pkcs9MessageDigest$instance;

export interface Pkcs9SigningTime$instance extends Pkcs9AttributeObject {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs9SigningTime: never;

    readonly SigningTime: DateTime;
    CopyFrom(asnEncodedData: AsnEncodedData): void;
}


export const Pkcs9SigningTime: {
    new(): Pkcs9SigningTime;
    new(signingTime: DateTime): Pkcs9SigningTime;
    new(encodedSigningTime: byte[]): Pkcs9SigningTime;
};


export type Pkcs9SigningTime = Pkcs9SigningTime$instance;

export interface PublicKeyInfo$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_PublicKeyInfo: never;

    readonly Algorithm: AlgorithmIdentifier;
    readonly KeyValue: byte[];
}


export const PublicKeyInfo: {
};


export type PublicKeyInfo = PublicKeyInfo$instance;

export interface RecipientInfo$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_RecipientInfo: never;

    readonly EncryptedKey: byte[];
    readonly KeyEncryptionAlgorithm: AlgorithmIdentifier;
    readonly RecipientIdentifier: SubjectIdentifier;
    readonly Type: RecipientInfoType;
    readonly Version: int;
}


export const RecipientInfo: {
};


export type RecipientInfo = RecipientInfo$instance;

export interface RecipientInfoCollection$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_RecipientInfoCollection: never;

    readonly __tsonic_iface_System_Collections_ICollection: never;
    readonly __tsonic_iface_System_Collections_IEnumerable: never;

    readonly Count: int;
    readonly IsSynchronized: boolean;
    readonly SyncRoot: unknown;
    CopyTo(array: ClrArray, index: int): void;
    CopyTo(array: RecipientInfo[], index: int): void;
    GetEnumerator(): RecipientInfoEnumerator;
}


export const RecipientInfoCollection: {
};


export type RecipientInfoCollection = RecipientInfoCollection$instance & { readonly [index: number]: RecipientInfo; };

export interface RecipientInfoEnumerator$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_RecipientInfoEnumerator: never;

    readonly __tsonic_iface_System_Collections_IEnumerator: never;

    readonly Current: RecipientInfo;
    MoveNext(): boolean;
    Reset(): void;
}


export const RecipientInfoEnumerator: {
};


export type RecipientInfoEnumerator = RecipientInfoEnumerator$instance;

export interface Rfc3161TimestampRequest$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Rfc3161TimestampRequest: never;

    readonly HasExtensions: boolean;
    readonly HashAlgorithmId: Oid;
    readonly RequestedPolicyId: Oid | null;
    readonly RequestSignerCertificate: boolean;
    readonly Version: int;
    Encode(): byte[];
    GetExtensions(): X509ExtensionCollection;
    GetMessageHash(): ReadOnlyMemory_1<System_Internal.Byte>;
    GetNonce(): Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>;
    ProcessResponse(responseBytes: ReadOnlyMemory_1<System_Internal.Byte>, bytesConsumed: int): Rfc3161TimestampToken;
    TryEncode(destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
}


export const Rfc3161TimestampRequest: {
    CreateFromData(data: ReadOnlySpan_1<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid | null, nonce?: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection | null): Rfc3161TimestampRequest;
    CreateFromHash(hash: ReadOnlyMemory_1<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid | null, nonce?: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection | null): Rfc3161TimestampRequest;
    CreateFromHash(hash: ReadOnlyMemory_1<System_Internal.Byte>, hashAlgorithmId: Oid, requestedPolicyId?: Oid | null, nonce?: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection | null): Rfc3161TimestampRequest;
    CreateFromSignerInfo(signerInfo: SignerInfo, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid | null, nonce?: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection | null): Rfc3161TimestampRequest;
    TryDecode(encodedBytes: ReadOnlyMemory_1<System_Internal.Byte>, request: Rfc3161TimestampRequest | null, bytesConsumed: int): boolean;
};


export type Rfc3161TimestampRequest = Rfc3161TimestampRequest$instance;

export interface Rfc3161TimestampToken$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Rfc3161TimestampToken: never;

    TokenInfo: Rfc3161TimestampTokenInfo;
    AsSignedCms(): SignedCms;
    VerifySignatureForData(data: ReadOnlySpan_1<System_Internal.Byte>, signerCertificate: X509Certificate2 | null, extraCandidates?: X509Certificate2Collection | null): boolean;
    VerifySignatureForHash(hash: ReadOnlySpan_1<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, signerCertificate: X509Certificate2 | null, extraCandidates?: X509Certificate2Collection | null): boolean;
    VerifySignatureForHash(hash: ReadOnlySpan_1<System_Internal.Byte>, hashAlgorithmId: Oid, signerCertificate: X509Certificate2 | null, extraCandidates?: X509Certificate2Collection | null): boolean;
    VerifySignatureForSignerInfo(signerInfo: SignerInfo, signerCertificate: X509Certificate2 | null, extraCandidates?: X509Certificate2Collection | null): boolean;
}


export const Rfc3161TimestampToken: {
    TryDecode(encodedBytes: ReadOnlyMemory_1<System_Internal.Byte>, token: Rfc3161TimestampToken | null, bytesConsumed: int): boolean;
};


export type Rfc3161TimestampToken = Rfc3161TimestampToken$instance;

export interface Rfc3161TimestampTokenInfo$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Rfc3161TimestampTokenInfo: never;

    readonly AccuracyInMicroseconds: Nullable_1<System_Internal.Int64>;
    readonly HasExtensions: boolean;
    readonly HashAlgorithmId: Oid;
    readonly IsOrdering: boolean;
    readonly PolicyId: Oid;
    readonly Timestamp: DateTimeOffset;
    readonly Version: int;
    Encode(): byte[];
    GetExtensions(): X509ExtensionCollection;
    GetMessageHash(): ReadOnlyMemory_1<System_Internal.Byte>;
    GetNonce(): Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>;
    GetSerialNumber(): ReadOnlyMemory_1<System_Internal.Byte>;
    GetTimestampAuthorityName(): Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>;
    TryEncode(destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
}


export const Rfc3161TimestampTokenInfo: {
    new(policyId: Oid, hashAlgorithmId: Oid, messageHash: ReadOnlyMemory_1<System_Internal.Byte>, serialNumber: ReadOnlyMemory_1<System_Internal.Byte>, timestamp: DateTimeOffset, accuracyInMicroseconds: Nullable_1<System_Internal.Int64>, isOrdering: boolean, nonce: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, timestampAuthorityName: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, extensions: X509ExtensionCollection | null): Rfc3161TimestampTokenInfo;
    TryDecode(encodedBytes: ReadOnlyMemory_1<System_Internal.Byte>, timestampTokenInfo: Rfc3161TimestampTokenInfo | null, bytesConsumed: int): boolean;
};


export type Rfc3161TimestampTokenInfo = Rfc3161TimestampTokenInfo$instance;

export interface SignedCms$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_SignedCms: never;

    readonly Certificates: X509Certificate2Collection;
    ContentInfo: ContentInfo;
    Detached: boolean;
    readonly SignerInfos: SignerInfoCollection;
    Version: int;
    AddCertificate(certificate: X509Certificate2): void;
    CheckHash(): void;
    CheckSignature(verifySignatureOnly: boolean): void;
    CheckSignature(extraStore: X509Certificate2Collection, verifySignatureOnly: boolean): void;
    ComputeSignature(): void;
    ComputeSignature(signer: CmsSigner): void;
    ComputeSignature(signer: CmsSigner, silent: boolean): void;
    Decode(encodedMessage: byte[]): void;
    Decode(encodedMessage: ReadOnlySpan_1<System_Internal.Byte>): void;
    Encode(): byte[];
    RemoveCertificate(certificate: X509Certificate2): void;
    RemoveSignature(index: int): void;
    RemoveSignature(signerInfo: SignerInfo): void;
}


export const SignedCms: {
    new(signerIdentifierType: SubjectIdentifierType, contentInfo: ContentInfo, detached: boolean): SignedCms;
    new(): SignedCms;
    new(signerIdentifierType: SubjectIdentifierType): SignedCms;
    new(contentInfo: ContentInfo): SignedCms;
    new(signerIdentifierType: SubjectIdentifierType, contentInfo: ContentInfo): SignedCms;
    new(contentInfo: ContentInfo, detached: boolean): SignedCms;
};


export type SignedCms = SignedCms$instance;

export interface SignerInfo$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_SignerInfo: never;

    readonly Certificate: X509Certificate2 | null;
    readonly CounterSignerInfos: SignerInfoCollection;
    readonly DigestAlgorithm: Oid;
    readonly SignatureAlgorithm: Oid;
    readonly SignedAttributes: CryptographicAttributeObjectCollection;
    readonly SignerIdentifier: SubjectIdentifier;
    readonly UnsignedAttributes: CryptographicAttributeObjectCollection;
    readonly Version: int;
    AddUnsignedAttribute(unsignedAttribute: AsnEncodedData): void;
    CheckHash(): void;
    CheckSignature(verifySignatureOnly: boolean): void;
    CheckSignature(extraStore: X509Certificate2Collection, verifySignatureOnly: boolean): void;
    ComputeCounterSignature(): void;
    ComputeCounterSignature(signer: CmsSigner): void;
    GetSignature(): byte[];
    RemoveCounterSignature(index: int): void;
    RemoveCounterSignature(counterSignerInfo: SignerInfo): void;
    RemoveUnsignedAttribute(unsignedAttribute: AsnEncodedData): void;
}


export const SignerInfo: {
};


export type SignerInfo = SignerInfo$instance;

export interface SignerInfoCollection$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_SignerInfoCollection: never;

    readonly __tsonic_iface_System_Collections_ICollection: never;
    readonly __tsonic_iface_System_Collections_IEnumerable: never;

    readonly Count: int;
    readonly IsSynchronized: boolean;
    readonly SyncRoot: unknown;
    CopyTo(array: ClrArray, index: int): void;
    CopyTo(array: SignerInfo[], index: int): void;
    GetEnumerator(): SignerInfoEnumerator;
}


export const SignerInfoCollection: {
};


export type SignerInfoCollection = SignerInfoCollection$instance & { readonly [index: number]: SignerInfo; };

export interface SignerInfoEnumerator$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_SignerInfoEnumerator: never;

    readonly __tsonic_iface_System_Collections_IEnumerator: never;

    readonly Current: SignerInfo;
    MoveNext(): boolean;
    Reset(): void;
}


export const SignerInfoEnumerator: {
};


export type SignerInfoEnumerator = SignerInfoEnumerator$instance;

export interface SubjectIdentifier$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_SubjectIdentifier: never;

    readonly Type: SubjectIdentifierType;
    readonly Value: unknown | null;
    MatchesCertificate(certificate: X509Certificate2): boolean;
}


export const SubjectIdentifier: {
};


export type SubjectIdentifier = SubjectIdentifier$instance;

export interface SubjectIdentifierOrKey$instance {
    readonly __tsonic_type_System_Security_Cryptography_Pkcs_SubjectIdentifierOrKey: never;

    readonly Type: SubjectIdentifierOrKeyType;
    readonly Value: unknown;
}


export const SubjectIdentifierOrKey: {
};


export type SubjectIdentifierOrKey = SubjectIdentifierOrKey$instance;