/**
 * Requirement Diagram Wrapper Class
 *
 * A unified API for building, mutating, and querying requirement diagrams.
 * Provides a fluent interface that wraps the RequirementAST.
 */
import { DiagramWrapper } from './diagram-wrapper.js';
import type { RelationshipType, Requirement as RequirementNode, RequirementAST, RequirementDirection, RequirementElement, RequirementRelationship, RequirementType, RiskLevel, VerifyMethod } from './types/requirement.js';
import type { RenderOptions } from './types/render-options.js';
/**
 * Options for adding a requirement
 */
export interface AddRequirementOptions {
    /** Requirement ID */
    id?: string;
    /** Requirement text/description */
    text?: string;
    /** Risk level */
    risk?: RiskLevel;
    /** Verification method */
    verifyMethod?: VerifyMethod;
}
/**
 * Options for adding an element
 */
export interface AddElementOptions {
    /** Element type (e.g., "simulation", "module") */
    type?: string;
    /** Document reference */
    docRef?: string;
}
/**
 * Query options for finding requirements
 */
export interface FindRequirementsQuery {
    /** Find requirements of this type */
    requirementType?: RequirementType;
    /** Find requirements with this risk level */
    risk?: RiskLevel;
    /** Find requirements with this verification method */
    verifyMethod?: VerifyMethod;
    /** Find requirements whose name contains this string */
    nameContains?: string;
    /** Find requirements whose text contains this string */
    textContains?: string;
}
/**
 * Query options for finding elements
 */
export interface FindElementsQuery {
    /** Find elements of this type */
    type?: string;
    /** Find elements whose name contains this string */
    nameContains?: string;
}
/**
 * Query options for finding relationships
 */
export interface FindRelationshipsQuery {
    /** Find relationships of this type */
    relationshipType?: RelationshipType;
    /** Find relationships from this source */
    source?: string;
    /** Find relationships to this target */
    target?: string;
}
/**
 * A fluent wrapper for RequirementAST that supports building, mutating, and querying.
 */
export declare class Requirement extends DiagramWrapper<RequirementAST> {
    private constructor();
    /**
     * Create a new empty requirement diagram
     * @param direction - Layout direction (default: 'TB')
     */
    static create(direction?: RequirementDirection): Requirement;
    /**
     * Create a Requirement wrapper from an existing AST
     * @param ast - The AST to wrap
     */
    static from(ast: RequirementAST): Requirement;
    /**
     * Parse Mermaid syntax and create a Requirement wrapper
     * @param text - Mermaid requirement diagram syntax
     */
    static parse(text: string): Requirement;
    /**
     * Render to Mermaid syntax
     * @param options - Render options
     */
    render(options?: RenderOptions): string;
    /**
     * Create a deep clone of this requirement diagram
     */
    clone(): Requirement;
    /**
     * Get the diagram direction
     */
    get direction(): RequirementDirection;
    /**
     * Get the number of requirements
     */
    get requirementCount(): number;
    /**
     * Get the number of elements
     */
    get elementCount(): number;
    /**
     * Get the number of relationships
     */
    get relationshipCount(): number;
    /**
     * Get all requirement names
     */
    get requirementNames(): string[];
    /**
     * Get all element names
     */
    get elementNames(): string[];
    /**
     * Add a requirement to the diagram
     * @param name - Requirement name
     * @param requirementType - Type of requirement (default: 'requirement')
     * @param options - Additional options
     */
    addRequirement(name: string, requirementType?: RequirementType, options?: AddRequirementOptions): this;
    /**
     * Get a requirement by name
     * @param name - Requirement name
     */
    getRequirement(name: string): RequirementNode | undefined;
    /**
     * Check if a requirement exists
     * @param name - Requirement name
     */
    hasRequirement(name: string): boolean;
    /**
     * Remove a requirement by name
     * @param name - Requirement name
     */
    removeRequirement(name: string): this;
    /**
     * Update a requirement's properties
     * @param name - Requirement name
     * @param updates - Properties to update
     */
    updateRequirement(name: string, updates: Partial<AddRequirementOptions>): this;
    /**
     * Add an element to the diagram
     * @param name - Element name
     * @param options - Additional options
     */
    addElement(name: string, options?: AddElementOptions): this;
    /**
     * Get an element by name
     * @param name - Element name
     */
    getElement(name: string): RequirementElement | undefined;
    /**
     * Check if an element exists
     * @param name - Element name
     */
    hasElement(name: string): boolean;
    /**
     * Remove an element by name
     * @param name - Element name
     */
    removeElement(name: string): this;
    /**
     * Update an element's properties
     * @param name - Element name
     * @param updates - Properties to update
     */
    updateElement(name: string, updates: Partial<AddElementOptions>): this;
    /**
     * Add a relationship between entities
     * @param source - Source entity name
     * @param target - Target entity name
     * @param relationshipType - Type of relationship
     */
    addRelationship(source: string, target: string, relationshipType: RelationshipType): this;
    /**
     * Get all relationships
     */
    getRelationships(): RequirementRelationship[];
    /**
     * Get relationships from a source
     * @param source - Source entity name
     */
    getRelationshipsFrom(source: string): RequirementRelationship[];
    /**
     * Get relationships to a target
     * @param target - Target entity name
     */
    getRelationshipsTo(target: string): RequirementRelationship[];
    /**
     * Remove a relationship
     * @param source - Source entity name
     * @param target - Target entity name
     * @param relationshipType - Optional: only remove if type matches
     */
    removeRelationship(source: string, target: string, relationshipType?: RelationshipType): this;
    /**
     * Find requirements matching a query
     * @param query - Query options
     */
    findRequirements(query: FindRequirementsQuery): RequirementNode[];
    /**
     * Find elements matching a query
     * @param query - Query options
     */
    findElements(query: FindElementsQuery): RequirementElement[];
    /**
     * Find relationships matching a query
     * @param query - Query options
     */
    findRelationships(query: FindRelationshipsQuery): RequirementRelationship[];
    /**
     * Define a CSS class
     * @param className - Class name
     * @param styles - CSS styles
     */
    defineClass(className: string, styles: string[]): this;
    /**
     * Apply a class to an entity
     * @param entityName - Entity name (requirement or element)
     * @param className - Class name to apply
     */
    addClass(entityName: string, className: string): this;
    /**
     * Remove a class from an entity
     * @param entityName - Entity name
     * @param className - Class name to remove
     */
    removeClass(entityName: string, className: string): this;
    /**
     * Set inline styles for an entity
     * @param entityName - Entity name
     * @param styles - CSS styles
     */
    setStyle(entityName: string, styles: string[]): this;
    /**
     * Set the accessibility title
     * @param title - Accessibility title
     */
    setAccTitle(title: string): this;
    /**
     * Set the accessibility description
     * @param description - Accessibility description
     */
    setAccDescription(description: string): this;
    /**
     * Set the diagram direction
     * @param direction - Layout direction
     */
    setDirection(direction: RequirementDirection): this;
}
//# sourceMappingURL=requirement.d.ts.map