import { Meta, Layer, AiTask, HumanTask, SystemTask, DataArtifactDefinition, ConstraintDefinition, TouchpointDefinition, WorkflowTemplate, Example } from './types.mjs';
export { ActorCategory, AtlasData, BaseTask, BuilderEdge, BuilderNode, BuilderState, Capability, ConstraintCategory, DataCategory, IOItem, IOSpec, ImplementationNotes, LayerGuidance, Node, NodeAttachment, NodeClass, NodeType, Persona, Project, Relation, Task, TemplateAttachment, TouchpointCategory, UxNotes, WorkflowTaskStep, WorkflowTemplateEdge } from './types.mjs';
export { ATLAS_DATA } from './data.mjs';

declare const META: Meta;

declare const LAYERS: Layer[];

declare const AI_TASKS: AiTask[];

declare const HUMAN_TASKS: HumanTask[];

declare const SYSTEM_TASKS: SystemTask[];

declare const DATA_ARTIFACTS: DataArtifactDefinition[];

declare const CONSTRAINTS: ConstraintDefinition[];

declare const TOUCHPOINTS: TouchpointDefinition[];

declare const WORKFLOW_TEMPLATES: WorkflowTemplate[];

declare const EXAMPLES: Example[];

type SearchableItem = AiTask | HumanTask | SystemTask | DataArtifactDefinition | ConstraintDefinition | TouchpointDefinition;
interface SearchOptions {
    /** Dimensions to search within (default: all) */
    dimensions?: Array<'ai' | 'human' | 'system' | 'data' | 'constraints' | 'touchpoints'>;
    /** Case sensitive search (default: false) */
    caseSensitive?: boolean;
    /** Search in description field (default: true) */
    searchDescription?: boolean;
    /** Limit number of results (default: no limit) */
    limit?: number;
}
/**
 * Search across all Atlas patterns by keyword
 *
 * @param query - Search query string
 * @param options - Search options
 * @returns Array of matching patterns
 *
 * @example
 * ```typescript
 * // Search all dimensions
 * const results = searchPatterns('review');
 *
 * // Search only human tasks
 * const humanResults = searchPatterns('review', { dimensions: ['human'] });
 *
 * // Case sensitive search
 * const exact = searchPatterns('API', { caseSensitive: true });
 * ```
 */
declare function searchPatterns(query: string, options?: SearchOptions): SearchableItem[];
/**
 * Get a specific pattern by ID (slug or target_id)
 *
 * @param id - Pattern ID (slug or target_id)
 * @returns The pattern if found, undefined otherwise
 *
 * @example
 * ```typescript
 * const task = getPattern('classify-intent');
 * const artifact = getPattern('embedding');
 * ```
 */
declare function getPattern(id: string): SearchableItem | undefined;
/**
 * Get all patterns from a specific dimension
 *
 * @param dimension - Dimension name
 * @returns Array of patterns in that dimension
 *
 * @example
 * ```typescript
 * const aiTasks = getPatternsByDimension('ai');
 * const constraints = getPatternsByDimension('constraints');
 * ```
 */
declare function getPatternsByDimension(dimension: 'ai' | 'human' | 'system' | 'data' | 'constraints' | 'touchpoints'): SearchableItem[];

/**
 * Filter AI/Human/System tasks by layer
 *
 * @param tasks - Array of tasks to filter
 * @param layerId - Layer ID to filter by
 * @returns Filtered tasks
 *
 * @example
 * ```typescript
 * import { AI_TASKS, filterByLayer } from '@quietloudlab/ai-interaction-atlas';
 *
 * const inboundTasks = filterByLayer(AI_TASKS, 'layer_inbound');
 * ```
 */
declare function filterByLayer<T extends AiTask | HumanTask | SystemTask>(tasks: T[], layerId: string): T[];
/**
 * Get all tasks in a specific layer
 *
 * @param layerId - Layer ID
 * @returns Object containing ai, human, and system tasks in that layer
 *
 * @example
 * ```typescript
 * const inbound = getTasksByLayer('layer_inbound');
 * console.log(inbound.ai); // All AI tasks in inbound layer
 * ```
 */
declare function getTasksByLayer(layerId: string): {
    ai: AiTask[];
    human: HumanTask[];
    system: SystemTask[];
};
/**
 * Get a layer definition by ID
 *
 * @param layerId - Layer ID
 * @returns Layer definition or undefined
 *
 * @example
 * ```typescript
 * const layer = getLayer('layer_inbound');
 * console.log(layer?.name); // "Inbound (Sensing & Structuring)"
 * ```
 */
declare function getLayer(layerId: string): Layer | undefined;
/**
 * Filter data artifacts by category
 *
 * @param category - Category to filter by (e.g., 'text', 'visual', 'audio')
 * @returns Filtered artifacts
 *
 * @example
 * ```typescript
 * const textArtifacts = filterArtifactsByCategory('text');
 * const visualArtifacts = filterArtifactsByCategory('visual');
 * ```
 */
declare function filterArtifactsByCategory(category: string): DataArtifactDefinition[];
/**
 * Filter constraints by category
 *
 * @param category - Category to filter by
 * @returns Filtered constraints
 *
 * @example
 * ```typescript
 * const qualityConstraints = filterConstraintsByCategory('Quality & Safety');
 * const performanceConstraints = filterConstraintsByCategory('Performance & Resource');
 * ```
 */
declare function filterConstraintsByCategory(category: string): ConstraintDefinition[];
/**
 * Filter touchpoints by category
 *
 * @param category - Category to filter by
 * @returns Filtered touchpoints
 *
 * @example
 * ```typescript
 * const screenTouchpoints = filterTouchpointsByCategory('Screen Interface');
 * const voiceTouchpoints = filterTouchpointsByCategory('Voice/Audio');
 * ```
 */
declare function filterTouchpointsByCategory(category: string): TouchpointDefinition[];
/**
 * Get all unique categories for a dimension
 *
 * @param dimension - Dimension to get categories from
 * @returns Array of unique category names
 *
 * @example
 * ```typescript
 * const artifactCategories = getCategories('data');
 * // ['text', 'visual', 'audio', 'structured', 'system']
 * ```
 */
declare function getCategories(dimension: 'data' | 'constraints' | 'touchpoints'): string[];
/**
 * Get statistics about the Atlas
 *
 * @returns Object with counts for each dimension
 *
 * @example
 * ```typescript
 * const stats = getAtlasStats();
 * console.log(stats);
 * // {
 * //   ai: 45,
 * //   human: 28,
 * //   system: 31,
 * //   data: 52,
 * //   constraints: 42,
 * //   touchpoints: 18,
 * //   total: 216
 * // }
 * ```
 */
declare function getAtlasStats(): {
    ai: number;
    human: number;
    system: number;
    data: number;
    constraints: number;
    touchpoints: number;
    layers: number;
    total: number;
};

/**
 * Type guards for runtime type checking
 */
declare function isAiTask(task: any): task is AiTask;
declare function isHumanTask(task: any): task is HumanTask;
declare function isSystemTask(task: any): task is SystemTask;
/**
 * Validation helpers
 */
/**
 * Check if a task ID exists in the Atlas
 *
 * @param taskId - Task ID to check
 * @returns true if the task exists
 *
 * @example
 * ```typescript
 * if (isValidTaskId('ai_classify_intent')) {
 *   console.log('Valid task!');
 * }
 * ```
 */
declare function isValidTaskId(taskId: string): boolean;
/**
 * Check if an artifact ID exists in the Atlas
 *
 * @param artifactId - Artifact ID to check
 * @returns true if the artifact exists
 */
declare function isValidArtifactId(artifactId: string): boolean;
/**
 * Check if a constraint ID exists in the Atlas
 *
 * @param constraintId - Constraint ID to check
 * @returns true if the constraint exists
 */
declare function isValidConstraintId(constraintId: string): boolean;
/**
 * Check if a touchpoint ID exists in the Atlas
 *
 * @param touchpointId - Touchpoint ID to check
 * @returns true if the touchpoint exists
 */
declare function isValidTouchpointId(touchpointId: string): boolean;
/**
 * Validate a workflow/canvas design
 *
 * @param nodeIds - Array of node IDs used in the workflow
 * @returns Validation result with invalid IDs if any
 *
 * @example
 * ```typescript
 * const result = validateWorkflow([
 *   'ai_classify_intent',
 *   'human_review_output',
 *   'system_log_event'
 * ]);
 *
 * if (!result.valid) {
 *   console.error('Invalid IDs:', result.invalidIds);
 * }
 * ```
 */
declare function validateWorkflow(nodeIds: string[]): {
    valid: boolean;
    invalidIds: string[];
};
/**
 * Get all valid task IDs
 *
 * @returns Array of all task IDs in the Atlas
 *
 * @example
 * ```typescript
 * const allTaskIds = getAllTaskIds();
 * console.log(allTaskIds.length); // e.g., 104
 * ```
 */
declare function getAllTaskIds(): string[];
/**
 * Get all valid artifact IDs
 *
 * @returns Array of all artifact IDs in the Atlas
 */
declare function getAllArtifactIds(): string[];
/**
 * Get all valid constraint IDs
 *
 * @returns Array of all constraint IDs in the Atlas
 */
declare function getAllConstraintIds(): string[];
/**
 * Get all valid touchpoint IDs
 *
 * @returns Array of all touchpoint IDs in the Atlas
 */
declare function getAllTouchpointIds(): string[];

export { AI_TASKS, AiTask, CONSTRAINTS, ConstraintDefinition, DATA_ARTIFACTS, DataArtifactDefinition, EXAMPLES, Example, HUMAN_TASKS, HumanTask, LAYERS, Layer, META, Meta, SYSTEM_TASKS, type SearchOptions, type SearchableItem, SystemTask, TOUCHPOINTS, TouchpointDefinition, WORKFLOW_TEMPLATES, WorkflowTemplate, filterArtifactsByCategory, filterByLayer, filterConstraintsByCategory, filterTouchpointsByCategory, getAllArtifactIds, getAllConstraintIds, getAllTaskIds, getAllTouchpointIds, getAtlasStats, getCategories, getLayer, getPattern, getPatternsByDimension, getTasksByLayer, isAiTask, isHumanTask, isSystemTask, isValidArtifactId, isValidConstraintId, isValidTaskId, isValidTouchpointId, searchPatterns, validateWorkflow };