@tsonic/microsoft-extensions 10.0.3 → 10.0.7

package/System.Security.Cryptography.Pkcs/internal/index.d.ts

@@ -10,15 +10,15 @@ import type { ptr } from "@tsonic/core/types.js";
 
 // Import types from other namespaces
 import type { CryptographicAttributeObject, CryptographicAttributeObjectCollection } from "../../System.Security.Cryptography/internal/index.js";
-import type { IEnumerable as IEnumerable__System_Collections_Generic } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Collections_Internal from "@tsonic/dotnet/System.Collections.js";
-import type { ICollection, IEnumerable, IEnumerator } from "@tsonic/dotnet/System.Collections.js";
-import type { ReadOnlyCollection } from "@tsonic/dotnet/System.Collections.ObjectModel.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Array as ClrArray, Boolean as ClrBoolean, Byte, Char, DateTime, DateTimeOffset, Enum, IComparable, IConvertible, IFormattable, Int32, Int64, ISpanFormattable, Nullable, Object as ClrObject, ReadOnlyMemory, ReadOnlySpan, Span, String as ClrString, Void } from "@tsonic/dotnet/System.js";
-import * as System_Security_Cryptography_Lib from "@tsonic/dotnet/System.Security.Cryptography.js";
-import type { AsnEncodedData, AsymmetricAlgorithm, CompositeMLDsa, CspParameters, HashAlgorithmName, MLDsa, Oid, PbeParameters, RSA, RSAEncryptionPadding, RSASignaturePadding, SlhDsa } from "@tsonic/dotnet/System.Security.Cryptography.js";
-import type { X509Certificate2, X509Certificate2Collection, X509ExtensionCollection, X509IncludeOption } from "@tsonic/dotnet/System.Security.Cryptography.X509Certificates.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 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,
@@ -60,6 +60,8 @@ export enum SubjectIdentifierType {
 
 
 export interface AlgorithmIdentifier$instance {
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_AlgorithmIdentifier: never;
+
     KeyLength: int;
     Oid: Oid;
     Parameters: byte[];
@@ -76,6 +78,8 @@ export const 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 | undefined;
@@ -93,6 +97,11 @@ export const 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 [index: number]: CmsRecipient;
@@ -115,6 +124,10 @@ export const CmsRecipientCollection: {
 export type CmsRecipientCollection = CmsRecipientCollection$instance;
 
 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;
@@ -128,6 +141,8 @@ export const CmsRecipientEnumerator: {
 export type CmsRecipientEnumerator = CmsRecipientEnumerator$instance;
 
 export interface CmsSigner$instance {
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_CmsSigner: never;
+
     get Certificate(): X509Certificate2 | undefined;
     set Certificate(value: X509Certificate2 | undefined);
     readonly Certificates: X509Certificate2Collection;
@@ -160,6 +175,8 @@ export const 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;
 }
@@ -169,13 +186,15 @@ export const ContentInfo: {
     new(content: byte[]): ContentInfo;
     new(contentType: Oid, content: byte[]): ContentInfo;
     GetContentType(encodedMessage: byte[]): Oid;
-    GetContentType(encodedMessage: ReadOnlySpan<System_Internal.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;
@@ -183,7 +202,7 @@ export interface EnvelopedCms$instance {
     UnprotectedAttributes: CryptographicAttributeObjectCollection;
     Version: int;
     Decode(encodedMessage: byte[]): void;
-    Decode(encodedMessage: ReadOnlySpan<System_Internal.Byte>): void;
+    Decode(encodedMessage: ReadOnlySpan_1<System_Internal.Byte>): void;
     Decrypt(): void;
     Decrypt(recipientInfo: RecipientInfo): void;
     Decrypt(recipientInfo: RecipientInfo, extraStore: X509Certificate2Collection): void;
@@ -205,6 +224,8 @@ export const 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;
@@ -222,6 +243,8 @@ 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;
@@ -236,17 +259,19 @@ 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[], pbeParameters: PbeParameters): void;
-    AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, passwordBytes: ReadOnlySpan<System_Internal.Byte>, pbeParameters: PbeParameters): void;
+    AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, passwordBytes: ReadOnlySpan_1<System_Internal.Byte>, pbeParameters: PbeParameters): void;
     AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, password: string, pbeParameters: PbeParameters): void;
-    AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, password: ReadOnlySpan<System_Internal.Char>, pbeParameters: PbeParameters): void;
+    AddSafeContentsEncrypted(safeContents: Pkcs12SafeContents, password: ReadOnlySpan_1<System_Internal.Char>, pbeParameters: PbeParameters): void;
     AddSafeContentsUnencrypted(safeContents: Pkcs12SafeContents): void;
     Encode(): byte[];
     SealWithMac(password: string, hashAlgorithm: HashAlgorithmName, iterationCount: int): void;
-    SealWithMac(password: ReadOnlySpan<System_Internal.Char>, hashAlgorithm: HashAlgorithmName, iterationCount: int): void;
+    SealWithMac(password: ReadOnlySpan_1<System_Internal.Char>, hashAlgorithm: HashAlgorithmName, iterationCount: int): void;
     SealWithoutIntegrity(): void;
-    TryEncode(destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
+    TryEncode(destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
 }
 
 
@@ -258,7 +283,9 @@ export const Pkcs12Builder: {
 export type Pkcs12Builder = Pkcs12Builder$instance;
 
 export interface Pkcs12CertBag$instance extends Pkcs12SafeBag {
-    readonly EncodedCertificate: ReadOnlyMemory<System_Internal.Byte>;
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12CertBag: never;
+
+    readonly EncodedCertificate: ReadOnlyMemory_1<System_Internal.Byte>;
     readonly IsX509Certificate: boolean;
     GetCertificate(): X509Certificate2;
     GetCertificateType(): Oid;
@@ -266,71 +293,79 @@ export interface Pkcs12CertBag$instance extends Pkcs12SafeBag {
 
 
 export const Pkcs12CertBag: {
-    new(certificateType: Oid, encodedCertificate: ReadOnlyMemory<System_Internal.Byte>): Pkcs12CertBag;
+    new(certificateType: Oid, encodedCertificate: ReadOnlyMemory_1<System_Internal.Byte>): Pkcs12CertBag;
 };
 
 
 export type Pkcs12CertBag = Pkcs12CertBag$instance;
 
 export interface Pkcs12Info$instance {
-    AuthenticatedSafe: ReadOnlyCollection<Pkcs12SafeContents>;
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12Info: never;
+
+    AuthenticatedSafe: ReadOnlyCollection_1<Pkcs12SafeContents>;
     IntegrityMode: Pkcs12IntegrityMode;
     VerifyMac(password: string): boolean;
-    VerifyMac(password: ReadOnlySpan<System_Internal.Char>): boolean;
+    VerifyMac(password: ReadOnlySpan_1<System_Internal.Char>): boolean;
 }
 
 
 export const Pkcs12Info: {
-    Decode(encodedBytes: ReadOnlyMemory<System_Internal.Byte>, bytesConsumed: int, skipCopy?: boolean): 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 Pkcs8PrivateKey: ReadOnlyMemory<System_Internal.Byte>;
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12KeyBag: never;
+
+    readonly Pkcs8PrivateKey: ReadOnlyMemory_1<System_Internal.Byte>;
 }
 
 
 export const Pkcs12KeyBag: {
-    new(pkcs8PrivateKey: ReadOnlyMemory<System_Internal.Byte>, skipCopy: boolean): 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<System_Internal.Byte>;
+    readonly EncodedBagValue: ReadOnlyMemory_1<System_Internal.Byte>;
     Encode(): byte[];
     GetBagId(): Oid;
-    TryEncode(destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
+    TryEncode(destination: Span_1<System_Internal.Byte>, bytesWritten: int): boolean;
 }
 
 
-export const Pkcs12SafeBag: (abstract new(bagIdValue: string, encodedBagValue: ReadOnlyMemory<System_Internal.Byte>, skipCopy: boolean) => Pkcs12SafeBag) & {
+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<System_Internal.Byte>): Pkcs12SecretBag;
+    AddSecret(secretType: Oid, secretValue: ReadOnlyMemory_1<System_Internal.Byte>): Pkcs12SecretBag;
     AddShroudedKey(key: AsymmetricAlgorithm, passwordBytes: byte[], pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
-    AddShroudedKey(key: AsymmetricAlgorithm, passwordBytes: ReadOnlySpan<System_Internal.Byte>, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
+    AddShroudedKey(key: AsymmetricAlgorithm, passwordBytes: ReadOnlySpan_1<System_Internal.Byte>, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
     AddShroudedKey(key: AsymmetricAlgorithm, password: string, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
-    AddShroudedKey(key: AsymmetricAlgorithm, password: ReadOnlySpan<System_Internal.Char>, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
+    AddShroudedKey(key: AsymmetricAlgorithm, password: ReadOnlySpan_1<System_Internal.Char>, pbeParameters: PbeParameters): Pkcs12ShroudedKeyBag;
     Decrypt(passwordBytes: byte[]): void;
-    Decrypt(passwordBytes: ReadOnlySpan<System_Internal.Byte>): void;
+    Decrypt(passwordBytes: ReadOnlySpan_1<System_Internal.Byte>): void;
     Decrypt(password: string): void;
-    Decrypt(password: ReadOnlySpan<System_Internal.Char>): void;
-    GetBags(): IEnumerable__System_Collections_Generic<Pkcs12SafeBag>;
+    Decrypt(password: ReadOnlySpan_1<System_Internal.Char>): void;
+    GetBags(): IEnumerable_1<Pkcs12SafeBag>;
 }
 
 
@@ -342,6 +377,8 @@ export const Pkcs12SafeContents: {
 export type Pkcs12SafeContents = Pkcs12SafeContents$instance;
 
 export interface Pkcs12SafeContentsBag$instance extends Pkcs12SafeBag {
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12SafeContentsBag: never;
+
     get SafeContents(): Pkcs12SafeContents | undefined;
     set SafeContents(value: Pkcs12SafeContents | undefined);
 }
@@ -354,7 +391,9 @@ export const Pkcs12SafeContentsBag: {
 export type Pkcs12SafeContentsBag = Pkcs12SafeContentsBag$instance;
 
 export interface Pkcs12SecretBag$instance extends Pkcs12SafeBag {
-    readonly SecretValue: ReadOnlyMemory<System_Internal.Byte>;
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12SecretBag: never;
+
+    readonly SecretValue: ReadOnlyMemory_1<System_Internal.Byte>;
     GetSecretType(): Oid;
 }
 
@@ -366,43 +405,49 @@ export const Pkcs12SecretBag: {
 export type Pkcs12SecretBag = Pkcs12SecretBag$instance;
 
 export interface Pkcs12ShroudedKeyBag$instance extends Pkcs12SafeBag {
-    readonly EncryptedPkcs8PrivateKey: ReadOnlyMemory<System_Internal.Byte>;
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs12ShroudedKeyBag: never;
+
+    readonly EncryptedPkcs8PrivateKey: ReadOnlyMemory_1<System_Internal.Byte>;
 }
 
 
 export const Pkcs12ShroudedKeyBag: {
-    new(encryptedPkcs8PrivateKey: ReadOnlyMemory<System_Internal.Byte>, skipCopy: boolean): 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<ReadOnlyMemory<System_Internal.Byte>>;
+    readonly AlgorithmParameters: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>;
     readonly Attributes: CryptographicAttributeObjectCollection;
-    readonly PrivateKeyBytes: ReadOnlyMemory<System_Internal.Byte>;
+    readonly PrivateKeyBytes: ReadOnlyMemory_1<System_Internal.Byte>;
     Encode(): byte[];
-    Encrypt(password: ReadOnlySpan<System_Internal.Char>, pbeParameters: PbeParameters): byte[];
-    Encrypt(passwordBytes: ReadOnlySpan<System_Internal.Byte>, pbeParameters: PbeParameters): byte[];
-    TryEncode(destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
-    TryEncrypt(password: ReadOnlySpan<System_Internal.Char>, pbeParameters: PbeParameters, destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
-    TryEncrypt(passwordBytes: ReadOnlySpan<System_Internal.Byte>, pbeParameters: PbeParameters, destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
+    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<ReadOnlyMemory<System_Internal.Byte>>, privateKey: ReadOnlyMemory<System_Internal.Byte>, skipCopies: boolean): 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<System_Internal.Byte>, bytesRead: int, skipCopy?: boolean): Pkcs8PrivateKeyInfo;
-    DecryptAndDecode(passwordBytes: ReadOnlySpan<System_Internal.Byte>, source: ReadOnlyMemory<System_Internal.Byte>, bytesRead: int): Pkcs8PrivateKeyInfo;
-    DecryptAndDecode(password: ReadOnlySpan<System_Internal.Char>, source: ReadOnlyMemory<System_Internal.Byte>, bytesRead: int): 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 | undefined;
     CopyFrom(asnEncodedData: AsnEncodedData): void;
 }
@@ -419,6 +464,8 @@ export const 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;
 }
@@ -432,6 +479,8 @@ export const 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;
 }
@@ -447,6 +496,8 @@ export const 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;
 }
@@ -462,7 +513,9 @@ export const Pkcs9DocumentName: {
 export type Pkcs9DocumentName = Pkcs9DocumentName$instance;
 
 export interface Pkcs9LocalKeyId$instance extends Pkcs9AttributeObject {
-    readonly KeyId: ReadOnlyMemory<System_Internal.Byte>;
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_Pkcs9LocalKeyId: never;
+
+    readonly KeyId: ReadOnlyMemory_1<System_Internal.Byte>;
     CopyFrom(asnEncodedData: AsnEncodedData): void;
 }
 
@@ -470,13 +523,15 @@ export interface Pkcs9LocalKeyId$instance extends Pkcs9AttributeObject {
 export const Pkcs9LocalKeyId: {
     new(): Pkcs9LocalKeyId;
     new(keyId: byte[]): Pkcs9LocalKeyId;
-    new(keyId: ReadOnlySpan<System_Internal.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;
 }
@@ -490,6 +545,8 @@ export const 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;
 }
@@ -505,6 +562,8 @@ export const 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[];
 }
@@ -517,6 +576,8 @@ 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;
@@ -532,6 +593,11 @@ 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 [index: number]: RecipientInfo;
@@ -549,6 +615,10 @@ export const RecipientInfoCollection: {
 export type RecipientInfoCollection = RecipientInfoCollection$instance;
 
 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;
@@ -562,6 +632,8 @@ 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 | undefined;
@@ -569,43 +641,47 @@ export interface Rfc3161TimestampRequest$instance {
     readonly Version: int;
     Encode(): byte[];
     GetExtensions(): X509ExtensionCollection;
-    GetMessageHash(): ReadOnlyMemory<System_Internal.Byte>;
-    GetNonce(): Nullable<ReadOnlyMemory<System_Internal.Byte>>;
-    ProcessResponse(responseBytes: ReadOnlyMemory<System_Internal.Byte>, bytesConsumed: int): Rfc3161TimestampToken;
-    TryEncode(destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
+    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<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid, nonce?: Nullable<ReadOnlyMemory<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection): Rfc3161TimestampRequest;
-    CreateFromHash(hash: ReadOnlyMemory<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid, nonce?: Nullable<ReadOnlyMemory<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection): Rfc3161TimestampRequest;
-    CreateFromHash(hash: ReadOnlyMemory<System_Internal.Byte>, hashAlgorithmId: Oid, requestedPolicyId?: Oid, nonce?: Nullable<ReadOnlyMemory<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection): Rfc3161TimestampRequest;
-    CreateFromSignerInfo(signerInfo: SignerInfo, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid, nonce?: Nullable<ReadOnlyMemory<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection): Rfc3161TimestampRequest;
-    TryDecode(encodedBytes: ReadOnlyMemory<System_Internal.Byte>, request: Rfc3161TimestampRequest, bytesConsumed: int): boolean;
+    CreateFromData(data: ReadOnlySpan_1<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid, nonce?: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection): Rfc3161TimestampRequest;
+    CreateFromHash(hash: ReadOnlyMemory_1<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid, nonce?: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection): Rfc3161TimestampRequest;
+    CreateFromHash(hash: ReadOnlyMemory_1<System_Internal.Byte>, hashAlgorithmId: Oid, requestedPolicyId?: Oid, nonce?: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection): Rfc3161TimestampRequest;
+    CreateFromSignerInfo(signerInfo: SignerInfo, hashAlgorithm: HashAlgorithmName, requestedPolicyId?: Oid, nonce?: Nullable_1<ReadOnlyMemory_1<System_Internal.Byte>>, requestSignerCertificates?: boolean, extensions?: X509ExtensionCollection): Rfc3161TimestampRequest;
+    TryDecode(encodedBytes: ReadOnlyMemory_1<System_Internal.Byte>, request: Rfc3161TimestampRequest, 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<System_Internal.Byte>, signerCertificate: X509Certificate2, extraCandidates?: X509Certificate2Collection): boolean;
-    VerifySignatureForHash(hash: ReadOnlySpan<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, signerCertificate: X509Certificate2, extraCandidates?: X509Certificate2Collection): boolean;
-    VerifySignatureForHash(hash: ReadOnlySpan<System_Internal.Byte>, hashAlgorithmId: Oid, signerCertificate: X509Certificate2, extraCandidates?: X509Certificate2Collection): boolean;
+    VerifySignatureForData(data: ReadOnlySpan_1<System_Internal.Byte>, signerCertificate: X509Certificate2, extraCandidates?: X509Certificate2Collection): boolean;
+    VerifySignatureForHash(hash: ReadOnlySpan_1<System_Internal.Byte>, hashAlgorithm: HashAlgorithmName, signerCertificate: X509Certificate2, extraCandidates?: X509Certificate2Collection): boolean;
+    VerifySignatureForHash(hash: ReadOnlySpan_1<System_Internal.Byte>, hashAlgorithmId: Oid, signerCertificate: X509Certificate2, extraCandidates?: X509Certificate2Collection): boolean;
     VerifySignatureForSignerInfo(signerInfo: SignerInfo, signerCertificate: X509Certificate2, extraCandidates?: X509Certificate2Collection): boolean;
 }
 
 
 export const Rfc3161TimestampToken: {
-    TryDecode(encodedBytes: ReadOnlyMemory<System_Internal.Byte>, token: Rfc3161TimestampToken, bytesConsumed: int): boolean;
+    TryDecode(encodedBytes: ReadOnlyMemory_1<System_Internal.Byte>, token: Rfc3161TimestampToken, bytesConsumed: int): boolean;
 };
 
 
 export type Rfc3161TimestampToken = Rfc3161TimestampToken$instance;
 
 export interface Rfc3161TimestampTokenInfo$instance {
-    readonly AccuracyInMicroseconds: Nullable<System_Internal.Int64>;
+    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;
@@ -614,23 +690,25 @@ export interface Rfc3161TimestampTokenInfo$instance {
     readonly Version: int;
     Encode(): byte[];
     GetExtensions(): X509ExtensionCollection;
-    GetMessageHash(): ReadOnlyMemory<System_Internal.Byte>;
-    GetNonce(): Nullable<ReadOnlyMemory<System_Internal.Byte>>;
-    GetSerialNumber(): ReadOnlyMemory<System_Internal.Byte>;
-    GetTimestampAuthorityName(): Nullable<ReadOnlyMemory<System_Internal.Byte>>;
-    TryEncode(destination: Span<System_Internal.Byte>, bytesWritten: int): boolean;
+    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<System_Internal.Byte>, serialNumber: ReadOnlyMemory<System_Internal.Byte>, timestamp: DateTimeOffset, accuracyInMicroseconds: Nullable<System_Internal.Int64>, isOrdering: boolean, nonce: Nullable<ReadOnlyMemory<System_Internal.Byte>>, timestampAuthorityName: Nullable<ReadOnlyMemory<System_Internal.Byte>>, extensions: X509ExtensionCollection): Rfc3161TimestampTokenInfo;
-    TryDecode(encodedBytes: ReadOnlyMemory<System_Internal.Byte>, timestampTokenInfo: Rfc3161TimestampTokenInfo, bytesConsumed: int): boolean;
+    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): Rfc3161TimestampTokenInfo;
+    TryDecode(encodedBytes: ReadOnlyMemory_1<System_Internal.Byte>, timestampTokenInfo: Rfc3161TimestampTokenInfo, 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;
@@ -644,7 +722,7 @@ export interface SignedCms$instance {
     ComputeSignature(signer: CmsSigner): void;
     ComputeSignature(signer: CmsSigner, silent: boolean): void;
     Decode(encodedMessage: byte[]): void;
-    Decode(encodedMessage: ReadOnlySpan<System_Internal.Byte>): void;
+    Decode(encodedMessage: ReadOnlySpan_1<System_Internal.Byte>): void;
     Encode(): byte[];
     RemoveCertificate(certificate: X509Certificate2): void;
     RemoveSignature(index: int): void;
@@ -665,6 +743,8 @@ export const SignedCms: {
 export type SignedCms = SignedCms$instance;
 
 export interface SignerInfo$instance {
+    readonly __tsonic_type_System_Security_Cryptography_Pkcs_SignerInfo: never;
+
     readonly Certificate: X509Certificate2 | undefined;
     readonly CounterSignerInfos: SignerInfoCollection;
     readonly DigestAlgorithm: Oid;
@@ -693,6 +773,11 @@ 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 [index: number]: SignerInfo;
@@ -710,6 +795,10 @@ export const SignerInfoCollection: {
 export type SignerInfoCollection = SignerInfoCollection$instance;
 
 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;
@@ -723,6 +812,8 @@ 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 | undefined;
     MatchesCertificate(certificate: X509Certificate2): boolean;
@@ -736,6 +827,8 @@ 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;
 }