import { _PdfBigInt } from './pdf-big-integer';
import { _PdfCertificateIdentifier } from './pdf-certificate-identifier';
import { _PdfCertificateTable } from './pdf-certificate-table';
import { _PdfSubjectKeyIdentifier } from './pdf-key-identifier';
import { _PdfX509Certificates } from './x509/x509-certificate';
import { _PdfCipherParameter } from './x509/x509-cipher-handler';
import { _PdfAbstractSyntaxElement } from './asn1/abstract-syntax';
export interface _PdfKeyEntry {
    privateKey: any;
    attributes: Record<string, any>;
}
/**
 * PKCS#7 / PKCS#12 certificate and key container helper with parsing and extraction utilities.
 *
 * @private
 */
export declare class _PdfPublicKeyCryptographyCertificate {
    /**
     * Raw ASN.1 certificate chain elements extracted from the container.
     *
     * @private
     * @type {_PdfAbstractSyntaxElement[]}
     */
    _certificateChain: _PdfAbstractSyntaxElement[];
    /**
     * Map of key identifiers/names to key entries or private key structures.
     *
     * @private
     * @type {Map<string, any>}
     */
    _keys: Map<string, any>;
    /**
     * Mapping of local identifier strings to hex key names.
     *
     * @private
     * @type {Map<string,string>}
     */
    _localIdentifiers: Map<string, string>;
    /**
     * OID for data content type.
     *
     * @private
     * @type {string}
     */
    _data: string;
    /**
     * OID for encrypted data content type.
     *
     * @private
     * @type {string}
     */
    _encryptedData: string;
    /**
     * OID for certificate bag in PKCS#12.
     *
     * @private
     * @type {string}
     */
    _certificateBag: string;
    /**
     * OID for shroudedKeyBag in PKCS#12.
     *
     * @private
     * @type {string}
     */
    _shroudedKeyBag: string;
    /**
     * OID for keyBag in PKCS#12.
     *
     * @private
     * @type {string}
     */
    _keyBag: string;
    /**
     * Attributes parsed from the container metadata.
     *
     * @private
     * @type {Record<string, any>}
     */
    _attributes: Record<string, any>;
    /**
     * Table of named certificates (used for lookup by friendly name).
     *
     * @private
     * @type {_PdfCertificateTable}
     */
    _certificates: _PdfCertificateTable;
    /**
     * Map from certificate identifier to parsed certificate chain container.
     *
     * @private
     * @type {Map<_PdfCertificateIdentifier,_PdfX509Certificates>}
     */
    _chainCertificates: Map<_PdfCertificateIdentifier, _PdfX509Certificates>;
    /**
     * Map from key hex name to parsed certificates for that key.
     *
     * @private
     * @type {Map<string,_PdfX509Certificates>}
     */
    _keyCertificates: Map<string, _PdfX509Certificates>;
    /**
     * Cached public key string representation when parsed.
     *
     * @private
     * @type {string}
     */
    _publicKeyString: string;
    /**
     * True when a private key was encountered without a local identifier.
     *
     * @private
     * @type {boolean}
     */
    _isUnMarkedKey: boolean;
    constructor(input?: Uint8Array, password?: string);
    /**
     * Create a subject key identifier helper from the provided public key parameters.
     *
     * @private
     * @param {_PdfCipherParameter} publicKey - Parsed public key parameters.
     * @param {Uint8Array} id - Raw key identifier bytes.
     * @returns {_PdfSubjectKeyIdentifier} Constructed subject key identifier helper.
     */
    _createSubjectKeyID(publicKey: _PdfCipherParameter, id: Uint8Array): _PdfSubjectKeyIdentifier;
    /**
     * Load and parse a PKCS container (PFX/P12) from bytes using the provided password.
     *
     * @private
     * @param {Uint8Array} input - The container bytes.
     * @param {string} password - Password to decrypt the container.
     * @returns {void}
     */
    _loadCertificate(input: Uint8Array, password: string): void;
    /**
     * Process and index a collection of ASN.1 certificate entries extracted from the container.
     *
     * @private
     * @param {any[]} certificateChain - Array of ASN.1 certificate elements.
     * @returns {void}
     */
    _processCertificateCollection(certificateChain: any[]): void;
    /**
     * Process a PKCS Data content element, extracting keys and certificates.
     *
     * @private
     * @param {_PdfAbstractSyntaxElement} contentElement - ASN.1 content element.
     * @param {string} password - Password for encrypted entries.
     * @returns {void}
     */
    _processData(contentElement: _PdfAbstractSyntaxElement, password: string): void;
    private _parseAndDecrypt;
    private _decodeDecryptedBytes;
    private _handleCertificateBag;
    private _extractPrivateKeyFromKeyInfo;
    private _extractLocalIdentifiers;
    private _storeKeyEntry;
    private _handleShroudedKeyBag;
    private _handleKeyBag;
    /**
     * Process an EncryptedData content element, dispatching to appropriate handlers.
     *
     * @private
     * @param {_PdfAbstractSyntaxElement} contentElement - EncryptedData ASN.1 element.
     * @param {string} password - Password used for decryption.
     * @returns {void}
     */
    _processEncryptedData(contentElement: _PdfAbstractSyntaxElement, password: string): void;
    /**
     * Construct a JavaScript private key object from raw RSA components.
     *
     * @private
     * @param {Uint8Array} modulus - RSA modulus bytes.
     * @param {Uint8Array} publicExponent - RSA public exponent bytes.
     * @param {Uint8Array} privateExponent - RSA private exponent bytes.
     * @param {Uint8Array} p - RSA prime1 bytes.
     * @param {Uint8Array} q - RSA prime2 bytes.
     * @param {Uint8Array} dP - RSA exponent1 bytes.
     * @param {Uint8Array} dQ - RSA exponent2 bytes.
     * @param {Uint8Array} inverse - RSA coefficient (qInv) bytes.
     * @returns {any} An object representing the private key and accessors.
     */
    _createPrivateKey(modulus: Uint8Array, publicExponent: Uint8Array, privateExponent: Uint8Array, p: Uint8Array, q: Uint8Array, dP: Uint8Array, dQ: Uint8Array, inverse: Uint8Array): any;
    /**
     * Validate that an RSA parameter value is present.
     *
     * @private
     * @param {string} name - Parameter name for error messages.
     * @param {_PdfBigInt} value - The big integer value to validate.
     * @returns {void}
     */
    _validateValue(name: string, value: _PdfBigInt): void;
    /**
     * Convert a Uint8Array containing big-endian bytes into a `_PdfBigInt` helper.
     *
     * @private
     * @param {Uint8Array} bytes - Big-endian byte sequence.
     * @returns {_PdfBigInt} The constructed big-integer helper.
     */
    _uint8ArrayToBigInt(bytes: Uint8Array): _PdfBigInt;
    /**
     * Encode a UTF-16BE password string into the byte format expected by PKCS#12.
     *
     * @private
     * @param {string} password - Password to encode.
     * @returns {Uint8Array} Encoded password bytes.
     */
    _getPassword(password: string): Uint8Array;
    /**
     * Decrypt encrypted content using the specified algorithm sequence and password.
     *
     * @private
     * @param {_PdfAbstractSyntaxElement[]} algorithmSeq - ASN.1 algorithm parameters sequence.
     * @param {Uint8Array} encryptedData - Encrypted payload bytes.
     * @param {string} password - Password used to derive keys.
     * @returns {Uint8Array} Decrypted bytes.
     */
    _getCryptographicData(algorithmSeq: _PdfAbstractSyntaxElement[], encryptedData: Uint8Array, password: string): Uint8Array;
    /**
     * Generate a derived key using PBKDF/PBE style iteration per PKCS specs.
     *
     * @private
     * @param {Uint8Array} password - Password bytes.
     * @param {Uint8Array} salt - Salt bytes.
     * @param {number} id - Diversifier id.
     * @param {number} iterations - Iteration count.
     * @param {number} n - Desired key length in bytes.
     * @param {{ hash(data: Uint8Array): Uint8Array; u: number; v: number }} hashValues - Hash function metadata.
     * @returns {Uint8Array} Derived key of length `n`.
     */
    _generateDerivedKey(password: Uint8Array, salt: Uint8Array, id: number, iterations: number, n: number, hashValues: {
        hash(data: Uint8Array): Uint8Array;
        u: number;
        v: number;
    }): Uint8Array;
    /**
     * Internal helper used by the key derivation routine to add blocks.
     *
     * @private
     * @param {Uint8Array} I - Buffer being adjusted.
     * @param {number} offset - Offset within I to apply the adjustment.
     * @param {Uint8Array} B - Block to add.
     * @returns {void}
     */
    _adjust(I: Uint8Array, offset: number, B: Uint8Array): void;
    /**
     * Retrieve certificates associated with the provided key or friendly name.
     *
     * @private
     * @param {string} certificateKey - Friendly name or identifier to lookup.
     * @returns {_PdfX509Certificates} Matching certificates container or undefined.
     */
    _getCertificate(certificateKey: string): _PdfX509Certificates;
    /**
     * Parse raw RSA private key octets into component byte arrays.
     *
     * @private
     * @param {Uint8Array} privateKeyOctets - DER-encoded RSA private key octets.
     * @returns {Record<string,Uint8Array>} Map of RSA component names to bytes.
     */
    _parsePrivateKey(privateKeyOctets: Uint8Array): Record<string, Uint8Array>;
    /**
     * Build the certificate chain for a given certificate key/name.
     *
     * @private
     * @param {string} key - Certificate key or friendly name.
     * @returns {_PdfX509Certificates[]|null} Array of certificate containers or null.
     */
    _getCertificateChain(key: string): _PdfX509Certificates[];
}