@birhaus/test-utils/dist/v3/index.d.ts

BIRHAUS v3.0 Radical Minimalist Testing Framework - Glass morphism validators, generous spacing tests, and v3 component validation utilities

/**
 * GlassMorphismValidator - Validates glass morphism effects in BIRHAUS v3.0 components
 *
 * Validates:
 * - Backdrop blur effects (backdrop-filter: blur)
 * - Backdrop saturation (backdrop-filter: saturate)
 * - Glass background opacity (semi-transparent backgrounds)
 * - Border transparency and glass borders
 * - Layered glass effects with proper z-index
 * - Performance impact of glass effects
 * - Accessibility considerations for glass backgrounds
 */
interface GlassEffectProperties {
    backdropBlur: string | null;
    backdropSaturate: string | null;
    backgroundColor: string | null;
    borderColor: string | null;
    borderOpacity: number;
    backgroundOpacity: number;
    zIndex: number;
    hasGradientOverlay: boolean;
}
interface GlassValidationRule {
    name: string;
    description: string;
    severity: 'error' | 'warning' | 'info';
    validate: (element: Element, computedStyle: CSSStyleDeclaration) => boolean;
    message: string;
    messageEs: string;
}
interface GlassValidationResult {
    isValid: boolean;
    rule: GlassValidationRule;
    element: Element;
    actualValue: string;
    expectedValue: string;
    severity: 'error' | 'warning' | 'info';
}
interface GlassValidationReport {
    totalElements: number;
    validElements: number;
    invalidElements: number;
    errors: GlassValidationResult[];
    warnings: GlassValidationResult[];
    info: GlassValidationResult[];
    performance: {
        glassElementsCount: number;
        estimatedRenderCost: number;
        recommendations: string[];
    };
}
/**
 * BIRHAUS v3.0 Glass Morphism Validation Rules
 */
declare const glassValidationRules: GlassValidationRule[];
/**
 * Extract glass effect properties from element
 */
declare function extractGlassProperties(element: Element): GlassEffectProperties;
/**
 * Validate glass morphism effects on element
 */
declare function validateGlassElement(element: Element, rules?: GlassValidationRule[]): GlassValidationResult[];
/**
 * Find all glass morphism elements in DOM
 */
declare function findGlassElements(container?: Element): Element[];
/**
 * Generate comprehensive glass morphism validation report
 */
declare function validateGlassMorphism(container?: Element, rules?: GlassValidationRule[]): GlassValidationReport;

/**
 * V3SpacingValidator - Validates generous spacing in BIRHAUS v3.0 components
 *
 * Validates:
 * - Generous spacing (2x traditional spacing)
 * - Consistent 8pt grid system compliance
 * - Proper padding and margin ratios
 * - Touch-friendly spacing (minimum 44px touch targets)
 * - Responsive spacing behavior
 * - Visual hierarchy through spacing
 */
interface SpacingMeasurement {
    paddingTop: number;
    paddingRight: number;
    paddingBottom: number;
    paddingLeft: number;
    marginTop: number;
    marginRight: number;
    marginBottom: number;
    marginLeft: number;
    gap: number;
    width: number;
    height: number;
}
interface V3SpacingRule {
    name: string;
    description: string;
    severity: 'error' | 'warning' | 'info';
    validate: (element: Element, measurements: SpacingMeasurement) => boolean;
    message: string;
    messageEs: string;
}
interface SpacingValidationResult {
    isValid: boolean;
    rule: V3SpacingRule;
    element: Element;
    measurements: SpacingMeasurement;
    expectedValue: string;
    actualValue: string;
    severity: 'error' | 'warning' | 'info';
}
interface V3SpacingReport {
    totalElements: number;
    validElements: number;
    invalidElements: number;
    errors: SpacingValidationResult[];
    warnings: SpacingValidationResult[];
    info: SpacingValidationResult[];
    spacingAnalysis: {
        averagePadding: number;
        averageMargin: number;
        gridCompliance: number;
        touchTargetCompliance: number;
        generousSpacingCompliance: number;
    };
}
/**
 * BIRHAUS v3.0 Generous Spacing Validation Rules
 */
declare const v3SpacingRules: V3SpacingRule[];
/**
 * Extract spacing measurements from element
 */
declare function extractSpacingMeasurements(element: Element): SpacingMeasurement;
/**
 * Validate v3.0 spacing on element
 */
declare function validateV3Spacing(element: Element, rules?: V3SpacingRule[]): SpacingValidationResult[];
/**
 * Find all relevant elements for spacing validation
 */
declare function findSpacingElements(container?: Element): Element[];
/**
 * Generate comprehensive v3.0 spacing validation report
 */
declare function validateV3SpacingSystem(container?: Element, rules?: V3SpacingRule[]): V3SpacingReport;

/**
 * V3AnimationValidator - Validates smooth animations in BIRHAUS v3.0 components
 *
 * Validates:
 * - Smooth easing curves (cubic-bezier, ease-smooth)
 * - Appropriate animation durations
 * - GPU acceleration (transform, opacity)
 * - Reduced motion respect
 * - Performance-friendly animation properties
 * - Consistent animation timing across components
 */
interface AnimationProperties {
    transitionProperty: string[];
    transitionDuration: number[];
    transitionTimingFunction: string[];
    transitionDelay: number[];
    animationName: string[];
    animationDuration: number[];
    animationTimingFunction: string[];
    animationFillMode: string[];
    transform: string;
    willChange: string;
    backfaceVisibility: string;
}
interface V3AnimationRule {
    name: string;
    description: string;
    severity: 'error' | 'warning' | 'info';
    validate: (element: Element, properties: AnimationProperties) => boolean;
    message: string;
    messageEs: string;
}
interface AnimationValidationResult {
    isValid: boolean;
    rule: V3AnimationRule;
    element: Element;
    properties: AnimationProperties;
    expectedValue: string;
    actualValue: string;
    severity: 'error' | 'warning' | 'info';
}
interface V3AnimationReport {
    totalElements: number;
    validElements: number;
    invalidElements: number;
    errors: AnimationValidationResult[];
    warnings: AnimationValidationResult[];
    info: AnimationValidationResult[];
    performance: {
        gpuAcceleratedElements: number;
        reducedMotionCompliantElements: number;
        smoothEasingElements: number;
        performanceScore: number;
        recommendations: string[];
    };
}
/**
 * BIRHAUS v3.0 Smooth Animation Validation Rules
 */
declare const v3AnimationRules: V3AnimationRule[];
/**
 * Extract animation properties from element
 */
declare function extractAnimationProperties(element: Element): AnimationProperties;
/**
 * Validate v3.0 animations on element
 */
declare function validateV3Animation(element: Element, rules?: V3AnimationRule[]): AnimationValidationResult[];
/**
 * Find all animated elements in DOM
 */
declare function findAnimatedElements(container?: Element): Element[];
/**
 * Generate comprehensive v3.0 animation validation report
 */
declare function validateV3AnimationSystem(container?: Element, rules?: V3AnimationRule[]): V3AnimationReport;

/**
 * @birhaus/test-utils/v3
 *
 * BIRHAUS v3.0 Radical Minimalist Testing Utilities
 * Specialized validators for v3.0 glass morphism, generous spacing, and smooth animations
 */

/**
 * Comprehensive v3.0 validation suite
 */
interface V3ComprehensiveReport {
    glassReport: GlassValidationReport;
    spacingReport: V3SpacingReport;
    animationReport: V3AnimationReport;
    overallScore: number;
    summary: {
        totalIssues: number;
        criticalIssues: number;
        recommendations: string[];
    };
}
/**
 * Run comprehensive BIRHAUS v3.0 validation
 */
declare function validateV3Comprehensive(container?: Element): V3ComprehensiveReport;
/**
 * Generate v3.0 validation summary report
 */
declare function generateV3Summary(report: V3ComprehensiveReport): string;

export { type AnimationProperties, type AnimationValidationResult, type GlassEffectProperties, type GlassValidationReport, type GlassValidationResult, type GlassValidationRule, type SpacingMeasurement, type SpacingValidationResult, type V3AnimationReport, type V3AnimationRule, type V3ComprehensiveReport, type V3SpacingReport, type V3SpacingRule, extractAnimationProperties, extractGlassProperties, extractSpacingMeasurements, findAnimatedElements, findGlassElements, findSpacingElements, generateV3Summary, glassValidationRules, v3AnimationRules, v3SpacingRules, validateGlassElement, validateGlassMorphism, validateV3Animation, validateV3AnimationSystem, validateV3Comprehensive, validateV3Spacing, validateV3SpacingSystem };