import { HexString, Member, PlatformID } from '@digitaldefiance/ecies-lib';
import { BlockSize } from '../../enumerations/blockSize';
import { Checksum } from '../../types/checksum';
import { BaseMemberDocument } from './baseMemberDocument';
/**
 * Concrete implementation of member document using CBLs.
 *
 * @remarks
 * This class uses the factory pattern to ensure proper initialization and validation.
 * Direct instantiation via `new MemberDocument()` is not allowed - use the static
 * `create()` method instead.
 *
 * @example
 * ```typescript
 * // Correct usage - use factory method
 * const doc = MemberDocument.create(publicMember, privateMember);
 *
 * // Incorrect usage - will throw FactoryPatternViolationError
 * // const doc = new MemberDocument(publicMember, privateMember);
 * ```
 *
 * @see Requirements 2.1, 2.2, 2.3, 2.4
 */
export declare class MemberDocument<TID extends PlatformID = Uint8Array> extends BaseMemberDocument {
    private cblService;
    private originalPublicMember;
    private originalPrivateMember;
    private readonly _blockSize;
    /**
     * Get the document ID as HexString
     */
    get id(): HexString;
    /**
     * Convert Member to storage data
     */
    private static toStorageData;
    /**
     * Private constructor - use the static create() factory method instead.
     *
     * @param factoryToken - Internal token to verify factory method usage
     * @param publicMember - The public member data
     * @param privateMember - The private member data
     * @param publicCBLId - Optional public CBL ID
     * @param privateCBLId - Optional private CBL ID
     * @param config - Optional configuration
     *
     * @throws {FactoryPatternViolationError} If called without the factory token
     *
     * @internal
     */
    constructor(factoryToken: symbol, publicMember: Member<TID>, privateMember: Member<TID>, publicCBLId?: Checksum, privateCBLId?: Checksum, config?: {
        blockSize?: BlockSize;
    });
    /**
     * Factory method to create a new MemberDocument instance.
     *
     * This is the only supported way to create MemberDocument instances.
     * Direct instantiation via `new MemberDocument()` is not allowed and will
     * throw a FactoryPatternViolationError.
     *
     * @param publicMember - The public member data containing public key information
     * @param privateMember - The private member data containing private key information
     * @param publicCBLId - Optional existing public CBL ID to associate with this document
     * @param privateCBLId - Optional existing private CBL ID to associate with this document
     * @param config - Optional configuration object
     * @param config.blockSize - The block size to use for CBL operations (default: BlockSize.Small)
     *
     * @returns A new MemberDocument instance
     *
     * @throws {MemberError} If the member data is invalid (missing id, type, or name)
     *
     * @example
     * ```typescript
     * import { MemberDocument } from './memberDocument';
     * import { Member } from '@digitaldefiance/ecies-lib';
     *
     * // Create members
     * const publicMember = Member.create({ ... });
     * const privateMember = Member.create({ ... });
     *
     * // Create document using factory method
     * const doc = MemberDocument.create(publicMember, privateMember);
     *
     * // With optional configuration
     * const docWithConfig = MemberDocument.create(
     *   publicMember,
     *   privateMember,
     *   undefined,
     *   undefined,
     *   { blockSize: BlockSize.Medium }
     * );
     * ```
     *
     * @see Requirements 2.1, 2.2, 2.3, 2.4, 2.5
     */
    static create<TID extends PlatformID = Uint8Array>(publicMember: Member<TID>, privateMember: Member<TID>, publicCBLId?: Checksum, privateCBLId?: Checksum, config?: {
        blockSize?: BlockSize;
    }): MemberDocument<TID>;
    /**
     * Get public CBL ID
     */
    getPublicCBL(): Checksum;
    /**
     * Get private CBL ID
     */
    getPrivateCBL(): Checksum;
    /**
     * Convert public data to CBL
     */
    toPublicCBL(): Promise<Uint8Array>;
    /**
     * Convert private data to CBL
     */
    toPrivateCBL(): Promise<Uint8Array>;
    /**
     * Create from CBLs
     */
    createFromCBLs(publicCBL: Uint8Array, privateCBL: Uint8Array): Promise<void>;
    /**
     * Generate CBLs for this document
     */
    generateCBLs(): Promise<void>;
    /**
     * Convert back to Member object by reconstructing from CBL data.
     *
     * This method verifies that CBLs have been generated and then uses
     * MemberCblService.hydrateMember() to reconstruct the member from
     * the stored CBL data, ensuring a true round-trip verification.
     *
     * @param usePrivate - If true, reconstruct from private CBL; otherwise use public CBL
     * @returns The reconstructed Member object
     * @throws {MemberError} with CBLNotGenerated if CBLs have not been generated
     * @throws {MemberError} with FailedToHydrateMember if hydration fails
     *
     * @requirements 4.1, 4.3
     */
    toMember(usePrivate?: boolean): Promise<Member<TID>>;
}
//# sourceMappingURL=memberDocument.d.ts.map