/**
 * Design Constraints Type Definitions
 *
 * Type system for defining and enforcing design constraints in AI-generated designs
 * through prompt engineering.
 */
/**
 * Types of design constraints
 */
declare enum ConstraintType {
    LAYOUT = "layout",
    COLOR = "color",
    TYPOGRAPHY = "typography",
    COMPONENT = "component",
    ACCESSIBILITY = "accessibility",
    SPACING = "spacing",
    SIZING = "sizing",
    ANIMATION = "animation",
    RESPONSIVE = "responsive",
    CUSTOM = "custom"
}
/**
 * Priority levels for constraints
 */
declare enum ConstraintPriority {
    CRITICAL = "critical",// Must be followed, validation fails if violated
    HIGH = "high",// Strongly recommended, generates warnings
    MEDIUM = "medium",// Recommended, generates suggestions
    LOW = "low"
}
/**
 * Layout system types
 */
declare enum LayoutSystem {
    GRID = "grid",
    FLEXBOX = "flexbox",
    STACK = "stack",
    ABSOLUTE = "absolute",
    FLOAT = "float"
}
/**
 * Color format types
 */
declare enum ColorFormat {
    HEX = "hex",
    RGB = "rgb",
    RGBA = "rgba",
    HSL = "hsl",
    HSLA = "hsla",
    NAMED = "named"
}
/**
 * WCAG compliance levels
 */
declare enum WCAGLevel {
    A = "A",
    AA = "AA",
    AAA = "AAA"
}
/**
 * Base constraint interface
 */
interface BaseConstraint {
    id: string;
    type: ConstraintType;
    name: string;
    description?: string;
    priority: ConstraintPriority;
    enabled: boolean;
    tags?: string[];
    metadata?: Record<string, unknown>;
}
/**
 * Layout constraint definition
 */
interface LayoutConstraint extends BaseConstraint {
    type: ConstraintType.LAYOUT;
    rules: {
        system?: LayoutSystem[];
        gridColumns?: number | {
            min: number;
            max: number;
        };
        gridGap?: string | number;
        maxWidth?: string | number;
        minWidth?: string | number;
        maxHeight?: string | number;
        minHeight?: string | number;
        aspectRatio?: string;
        alignment?: ('left' | 'center' | 'right' | 'justify')[];
        direction?: ('row' | 'column' | 'row-reverse' | 'column-reverse')[];
        wrap?: boolean;
        customRules?: Record<string, unknown>;
    };
}
/**
 * Color palette definition
 */
interface ColorPalette {
    primary: string[];
    secondary?: string[];
    accent?: string[];
    neutral?: string[];
    semantic?: {
        success?: string[];
        warning?: string[];
        error?: string[];
        info?: string[];
    };
    custom?: Record<string, string[]>;
}
/**
 * Color constraint definition
 */
interface ColorConstraint extends BaseConstraint {
    type: ConstraintType.COLOR;
    rules: {
        palette?: ColorPalette;
        formats?: ColorFormat[];
        maxColors?: number;
        minContrast?: number;
        allowedColors?: string[];
        forbiddenColors?: string[];
        colorHarmony?: ('monochromatic' | 'analogous' | 'complementary' | 'triadic' | 'tetradic')[];
        customRules?: Record<string, unknown>;
    };
}
/**
 * Typography scale
 */
interface TypographyScale {
    baseSize: number;
    ratio: number;
    sizes?: {
        xs?: number;
        sm?: number;
        base?: number;
        lg?: number;
        xl?: number;
        '2xl'?: number;
        '3xl'?: number;
        '4xl'?: number;
        [key: string]: number | undefined;
    };
}
/**
 * Typography constraint definition
 */
interface TypographyConstraint extends BaseConstraint {
    type: ConstraintType.TYPOGRAPHY;
    rules: {
        fontFamilies?: {
            heading?: string[];
            body?: string[];
            monospace?: string[];
            custom?: Record<string, string[]>;
        };
        scale?: TypographyScale;
        weights?: number[];
        lineHeights?: {
            tight?: number;
            normal?: number;
            relaxed?: number;
            loose?: number;
            custom?: Record<string, number>;
        };
        letterSpacing?: {
            tight?: string;
            normal?: string;
            wide?: string;
            custom?: Record<string, string>;
        };
        maxLevels?: number;
        customRules?: Record<string, unknown>;
    };
}
/**
 * Component size variants
 */
interface ComponentSizes {
    xs?: {
        width?: string;
        height?: string;
        padding?: string;
    };
    sm?: {
        width?: string;
        height?: string;
        padding?: string;
    };
    md?: {
        width?: string;
        height?: string;
        padding?: string;
    };
    lg?: {
        width?: string;
        height?: string;
        padding?: string;
    };
    xl?: {
        width?: string;
        height?: string;
        padding?: string;
    };
    [key: string]: {
        width?: string;
        height?: string;
        padding?: string;
    } | undefined;
}
/**
 * Component constraint definition
 */
interface ComponentConstraint extends BaseConstraint {
    type: ConstraintType.COMPONENT;
    rules: {
        allowedComponents?: string[];
        forbiddenComponents?: string[];
        sizes?: ComponentSizes;
        variants?: string[];
        maxNestingLevel?: number;
        composition?: {
            maxChildren?: number;
            allowedChildren?: string[];
            forbiddenChildren?: string[];
        };
        customRules?: Record<string, unknown>;
    };
}
/**
 * Accessibility constraint definition
 */
interface AccessibilityConstraint extends BaseConstraint {
    type: ConstraintType.ACCESSIBILITY;
    rules: {
        wcagLevel?: WCAGLevel;
        minContrast?: number;
        requireAltText?: boolean;
        requireAriaLabels?: boolean;
        keyboardNavigable?: boolean;
        focusVisible?: boolean;
        screenReaderOptimized?: boolean;
        colorBlindSafe?: boolean;
        minTouchTarget?: number;
        customRules?: Record<string, unknown>;
    };
}
/**
 * Spacing system
 */
interface SpacingSystem {
    base: number;
    scale?: number[];
    custom?: Record<string, number>;
}
/**
 * Spacing constraint definition
 */
interface SpacingConstraint extends BaseConstraint {
    type: ConstraintType.SPACING;
    rules: {
        system?: SpacingSystem;
        minSpacing?: number;
        maxSpacing?: number;
        consistent?: boolean;
        customRules?: Record<string, unknown>;
    };
}
/**
 * Custom constraint definition
 */
interface CustomConstraint extends BaseConstraint {
    type: ConstraintType.CUSTOM;
    rules: Record<string, unknown>;
    validator?: (design: unknown) => ValidationResult;
    promptGenerator?: (rules: Record<string, unknown>) => string[];
}
/**
 * Union type for all constraints
 */
type Constraint = LayoutConstraint | ColorConstraint | TypographyConstraint | ComponentConstraint | AccessibilityConstraint | SpacingConstraint | CustomConstraint;
/**
 * Validation severity levels
 */
declare enum ValidationSeverity {
    ERROR = "error",
    WARNING = "warning",
    INFO = "info",
    SUCCESS = "success"
}
/**
 * Validation issue
 */
interface ValidationIssue {
    constraintId: string;
    constraintType: ConstraintType;
    severity: ValidationSeverity;
    message: string;
    path?: string;
    expected?: unknown;
    actual?: unknown;
    suggestion?: string;
}
/**
 * Validation result
 */
interface ValidationResult {
    valid: boolean;
    score: number;
    issues: ValidationIssue[];
    summary: {
        total: number;
        passed: number;
        failed: number;
        warnings: number;
    };
    metadata?: Record<string, unknown>;
}
/**
 * Prompt instruction format
 */
interface PromptInstruction {
    section: string;
    priority: ConstraintPriority;
    instructions: string[];
    examples?: string[];
    metadata?: Record<string, unknown>;
}
/**
 * Constraint template
 */
interface ConstraintTemplate {
    id: string;
    name: string;
    description: string;
    category: string;
    version: string;
    author?: string;
    constraints: Constraint[];
    metadata?: Record<string, unknown>;
}
/**
 * Conditional constraint
 */
interface ConditionalConstraint {
    condition: {
        property: string;
        operator: 'equals' | 'notEquals' | 'contains' | 'greaterThan' | 'lessThan' | 'matches';
        value: unknown;
    };
    thenConstraints: Constraint[];
    elseConstraints?: Constraint[];
}
/**
 * Constraint set configuration
 */
interface ConstraintSetConfig {
    name: string;
    description?: string;
    baseTemplate?: string;
    constraints: Constraint[];
    conditionalConstraints?: ConditionalConstraint[];
    strict?: boolean;
    allowPartial?: boolean;
    metadata?: Record<string, unknown>;
}
/**
 * Conflict resolution strategy
 */
declare enum ConflictStrategy {
    OVERRIDE = "override",// Later constraint overrides earlier
    MERGE = "merge",// Merge constraint rules
    STRICT = "strict",// Fail on conflicts
    PRIORITIZE = "prioritize",// Use higher priority constraint
    IGNORE_DUPLICATES = "ignore_duplicates"
}
/**
 * Merge options
 */
interface MergeOptions {
    strategy: ConflictStrategy;
    preserveIds?: boolean;
    mergeTags?: boolean;
    mergeMetadata?: boolean;
}
/**
 * Natural language constraint input
 */
interface NaturalLanguageConstraint {
    description: string;
    type?: ConstraintType;
    priority?: ConstraintPriority;
    examples?: string[];
}
/**
 * Constraint parsing result
 */
interface ConstraintParseResult {
    success: boolean;
    constraints: Constraint[];
    errors?: string[];
    warnings?: string[];
    confidence?: number;
}
/**
 * Design output for validation
 */
interface DesignOutput {
    components?: unknown[];
    styles?: Record<string, unknown>;
    layout?: unknown;
    colors?: string[];
    typography?: unknown;
    metadata?: Record<string, unknown>;
    [key: string]: unknown;
}
/**
 * Prompt generation options
 */
interface PromptGenerationOptions {
    format?: 'structured' | 'natural' | 'mixed';
    includeExamples?: boolean;
    groupByType?: boolean;
    priorityThreshold?: ConstraintPriority;
    maxLength?: number;
    template?: string;
}

/**
 * Design Constraints System
 *
 * Define and enforce design constraints in AI-generated designs through
 * prompt engineering and validation.
 */

/**
 * Design Constraints Class
 *
 * Main class for managing design constraints, generating prompt instructions,
 * and validating AI-generated designs.
 */
declare class DesignConstraints {
    private constraints;
    private conditionalConstraints;
    private config;
    constructor(config: ConstraintSetConfig);
    /**
     * Define a new constraint
     */
    defineConstraint(constraint: Constraint): void;
    /**
     * Define a layout constraint
     */
    defineLayoutConstraint(id: string, rules: LayoutConstraint['rules'], options?: Partial<Omit<LayoutConstraint, 'type' | 'rules'>>): LayoutConstraint;
    /**
     * Define a color constraint
     */
    defineColorConstraint(id: string, rules: ColorConstraint['rules'], options?: Partial<Omit<ColorConstraint, 'type' | 'rules'>>): ColorConstraint;
    /**
     * Define a typography constraint
     */
    defineTypographyConstraint(id: string, rules: TypographyConstraint['rules'], options?: Partial<Omit<TypographyConstraint, 'type' | 'rules'>>): TypographyConstraint;
    /**
     * Define a component constraint
     */
    defineComponentConstraint(id: string, rules: ComponentConstraint['rules'], options?: Partial<Omit<ComponentConstraint, 'type' | 'rules'>>): ComponentConstraint;
    /**
     * Define an accessibility constraint
     */
    defineAccessibilityConstraint(id: string, rules: AccessibilityConstraint['rules'], options?: Partial<Omit<AccessibilityConstraint, 'type' | 'rules'>>): AccessibilityConstraint;
    /**
     * Define a spacing constraint
     */
    defineSpacingConstraint(id: string, rules: SpacingConstraint['rules'], options?: Partial<Omit<SpacingConstraint, 'type' | 'rules'>>): SpacingConstraint;
    /**
     * Define a custom constraint
     */
    defineCustomConstraint(id: string, rules: Record<string, unknown>, options?: Partial<Omit<CustomConstraint, 'type' | 'rules'>>): CustomConstraint;
    /**
     * Parse natural language constraint
     */
    parseNaturalLanguage(input: NaturalLanguageConstraint): ConstraintParseResult;
    /**
     * Convert constraints to prompt instructions
     */
    toPromptInstructions(options?: PromptGenerationOptions): PromptInstruction[];
    /**
     * Generate constraint instructions based on format
     */
    private generateConstraintInstructions;
    /**
     * Generate layout instructions
     */
    private generateLayoutInstructions;
    /**
     * Generate color instructions
     */
    private generateColorInstructions;
    /**
     * Generate typography instructions
     */
    private generateTypographyInstructions;
    /**
     * Generate component instructions
     */
    private generateComponentInstructions;
    /**
     * Generate accessibility instructions
     */
    private generateAccessibilityInstructions;
    /**
     * Generate spacing instructions
     */
    private generateSpacingInstructions;
    /**
     * Generate custom instructions
     */
    private generateCustomInstructions;
    /**
     * Validate design output against constraints
     */
    validateOutput(design: DesignOutput): ValidationResult;
    /**
     * Validate a single constraint
     */
    private validateConstraint;
    /**
     * Validate layout constraint
     */
    private validateLayoutConstraint;
    /**
     * Validate color constraint
     */
    private validateColorConstraint;
    /**
     * Validate typography constraint
     */
    private validateTypographyConstraint;
    /**
     * Validate component constraint
     */
    private validateComponentConstraint;
    /**
     * Validate accessibility constraint
     */
    private validateAccessibilityConstraint;
    /**
     * Validate spacing constraint
     */
    private validateSpacingConstraint;
    /**
     * Validate custom constraint
     */
    private validateCustomConstraint;
    /**
     * Merge constraints from another set
     */
    merge(other: DesignConstraints, options?: MergeOptions): DesignConstraints;
    /**
     * Extend base constraints
     */
    extend(base: DesignConstraints): DesignConstraints;
    /**
     * Get constraint by ID
     */
    getConstraint(id: string): Constraint | undefined;
    /**
     * Get all constraints
     */
    getAllConstraints(): Constraint[];
    /**
     * Get constraints by type
     */
    getConstraintsByType(type: ConstraintType): Constraint[];
    /**
     * Remove constraint
     */
    removeConstraint(id: string): boolean;
    /**
     * Enable/disable constraint
     */
    setConstraintEnabled(id: string, enabled: boolean): void;
    /**
     * Get constraint count
     */
    getConstraintCount(): number;
    /**
     * Clear all constraints
     */
    clear(): void;
    private groupByType;
    private getTypeSectionName;
    private getHighestPriority;
    private isPriorityAtLeast;
    private getSeverity;
    private generateExamples;
    private resolveConflict;
    private evaluateCondition;
    private getValueByPath;
}

export { type AccessibilityConstraint as A, type BaseConstraint as B, ConstraintType as C, DesignConstraints as D, LayoutSystem as L, type MergeOptions as M, type NaturalLanguageConstraint as N, type PromptInstruction as P, type SpacingSystem as S, type TypographyScale as T, ValidationSeverity as V, WCAGLevel as W, ConstraintPriority as a, ColorFormat as b, type LayoutConstraint as c, type ColorPalette as d, type ColorConstraint as e, type TypographyConstraint as f, type ComponentSizes as g, type ComponentConstraint as h, type SpacingConstraint as i, type CustomConstraint as j, type Constraint as k, type ValidationIssue as l, type ValidationResult as m, type ConstraintTemplate as n, type ConditionalConstraint as o, type ConstraintSetConfig as p, ConflictStrategy as q, type ConstraintParseResult as r, type DesignOutput as s, type PromptGenerationOptions as t };