/**
 * Property-Based Testing for Shamir Secret Sharing
 *
 * This module implements property-based tests that verify fundamental
 * properties of the Shamir Secret Sharing scheme. Rather than testing
 * specific inputs, property-based testing verifies that properties hold
 * for randomly generated inputs.
 *
 * Properties tested:
 * 1. Reconstruction succeeds with k shares
 * 2. Reconstruction fails with k-1 shares (information-theoretic)
 * 3. Share order independence
 * 4. Idempotency of reconstruction
 * 5. Commutativity of share combination
 *
 * @module security/crypto/shamir/property-tests
 */
export interface PropertyTestResult {
    property: string;
    passed: boolean;
    iterations: number;
    failedAt?: number;
    failureDetails?: unknown;
    timeMs: number;
}
export interface PropertyTestSuite {
    allPassed: boolean;
    results: PropertyTestResult[];
    totalIterations: number;
    totalTimeMs: number;
}
/**
 * PROPERTY: Reconstruction Completeness
 *
 * For any secret S and valid parameters (k, n):
 * split(S, k, n) produces shares such that
 * reconstruct(any_k_shares) = S
 *
 * This is the fundamental correctness property of Shamir's scheme.
 */
export declare function testReconstructionCompleteness(iterations?: number): PropertyTestResult;
/**
 * PROPERTY: Information-Theoretic Security
 *
 * For any secret S and parameters (k, n):
 * Given k-1 shares, every possible secret value is equally consistent
 * with those shares.
 *
 * This is tested by verifying that for k-1 shares, we can construct
 * a valid polynomial for any target secret value.
 */
export declare function testInformationTheoreticSecurity(iterations?: number): PropertyTestResult;
/**
 * PROPERTY: Share Order Independence
 *
 * The order in which shares are provided to reconstruction does not
 * affect the result.
 *
 * For any permutation pi of shares:
 * reconstruct(shares) = reconstruct(pi(shares))
 */
export declare function testShareOrderIndependence(iterations?: number): PropertyTestResult;
/**
 * PROPERTY: Reconstruction Idempotency
 *
 * Reconstructing the same shares multiple times yields the same result.
 *
 * For any set of shares:
 * reconstruct(shares) = reconstruct(shares) (for any number of calls)
 *
 * This verifies there are no hidden state issues or non-determinism.
 */
export declare function testReconstructionIdempotency(iterations?: number): PropertyTestResult;
/**
 * PROPERTY: Share Subset Equivalence
 *
 * Any k-subset of shares reconstructs the same secret.
 *
 * For any two k-subsets S1, S2 of shares:
 * reconstruct(S1) = reconstruct(S2)
 *
 * This verifies the "any k shares" property of Shamir's scheme.
 */
export declare function testShareSubsetEquivalence(iterations?: number): PropertyTestResult;
/**
 * PROPERTY: Lagrange Basis Partition of Unity
 *
 * For any set of distinct points x_1, ..., x_k,
 * Sum_{i=1}^{k} L_i(0) = 1
 *
 * where L_i is the i-th Lagrange basis polynomial.
 *
 * This is a fundamental property ensuring correct interpolation.
 */
export declare function testLagrangeBasisPartition(iterations?: number): PropertyTestResult;
/**
 * Run all property-based tests.
 */
export declare function runAllPropertyTests(iterationsPerTest?: number): PropertyTestSuite;
/**
 * Quick smoke test with minimal iterations.
 */
export declare function runQuickPropertyTests(): PropertyTestSuite;
//# sourceMappingURL=property-tests.d.ts.map