/**
 * Canonical Taxonomy Registry (T11186).
 *
 * Single source of truth for classification tags across decisions,
 * documents, tasks, and routing surfaces. Unifies the previously
 * fragmented vocabularies:
 *
 * - `BRAIN_DECISION_TYPES`   (memory-schema.ts) — 5 values
 * - `BRAIN_DECISION_CATEGORIES` (memory-schema.ts) — 3 values
 * - `BrainCognitiveType`      (brain.ts) — 3 values
 * - `BUILTIN_DOC_KINDS`       (docs-taxonomy.ts) — 10 values
 * - `labels_json`             (tasks schema) — free-form, 30+ ad-hoc labels
 * - `BrainEdgeKind`           (operations/brain.ts) — open-ended
 * - `BRAIN_PATTERN_TYPES`     (memory-schema.ts) — 5 values
 * - `BRAIN_OBSERVATION_TYPES` (memory-schema.ts) — 8 values
 *
 * The taxonomy is organized into **axes** — each tag is classified
 * by what dimension of classification it represents. A single tag
 * may belong to multiple axes (e.g., `adr` is both a doc_kind and
 * a decision type).
 *
 * ## Axes
 *
 * | Axis        | Purpose                                      |
 * |-------------|----------------------------------------------|
 * | `domain`    | Architectural subsystem or component area     |
 * | `type`      | Kind of artifact, decision, or entry          |
 * | `lifecycle` | Phase in the RCASD→IVTR pipeline              |
 * | `priority`  | Severity, urgency, or importance              |
 * | `doc_kind`  | Document classification (absorbs docs-taxonomy)|
 *
 * @task    T11186
 * @epic    T10520
 * @saga    T10516
 * @see     ADR-073 §1 — Task Hierarchy Charter
 * @see     packages/contracts/src/docs-taxonomy.ts — absorbed doc-kind subset
 */
/** Allowed tag axis values. */
export type TaxonomyAxis = 'domain' | 'type' | 'lifecycle' | 'priority' | 'doc_kind';
/**
 * Metadata for a single canonical tag in the unified taxonomy.
 */
export interface CanonicalTagMetadata {
    /** Canonical tag id, lowercase kebab-case. */
    readonly tag: string;
    /** Human label for display in CLI output and UIs. */
    readonly label: string;
    /** One-line description. */
    readonly description: string;
    /** Which classification axes this tag belongs to. */
    readonly axes: ReadonlyArray<TaxonomyAxis>;
    /**
     * Ad-hoc labels from tasks.labels_json that normalize to this tag.
     * Used by the backfill script.
     */
    readonly adhocAliases: ReadonlyArray<string>;
}
/**
 * Every canonical tag known to the system.
 *
 * Adding a tag here automatically makes it available for decisions,
 * task labels, doc classification, and routing surfaces. No other
 * file needs to be updated.
 */
export declare const BUILTIN_TAXONOMY_TAGS: ReadonlyArray<CanonicalTagMetadata>;
/** All canonical tag string values. */
export declare const CANONICAL_TAG_VALUES: string[];
/** All canonical tag type values (subset of ALL_TAGS with axis='type'). */
export declare const CANONICAL_TYPE_TAGS: ReadonlyArray<string>;
/** All canonical domain tag values. */
export declare const CANONICAL_DOMAIN_TAGS: ReadonlyArray<string>;
/** Canonical priority tag values in order. */
export declare const CANONICAL_PRIORITY_TAGS: readonly ["p0", "p1", "p2", "p3"];
/** Canonical lifecycle tag values in LOOM order. */
export declare const CANONICAL_LIFECYCLE_TAGS: readonly ["research", "consensus", "design", "specification", "decomposition", "implementation", "validation", "release"];
/** Doc-kind tags (absorbed from docs-taxonomy). */
export declare const CANONICAL_DOC_KIND_TAGS: ReadonlyArray<string>;
/** Error thrown for taxonomy validation failures. */
export declare class TaxonomyError extends Error {
    readonly invalidTags: string[];
    constructor(message: string, invalidTags: string[]);
}
/**
 * Canonical Taxonomy Registry — runtime accessor and validator.
 *
 * Use {@link TaxonomyRegistry.default} for the built-in singleton,
 * or construct with a custom tag list for testing.
 */
export declare class TaxonomyRegistry {
    private readonly byId;
    private readonly adhocMap;
    constructor(tags: ReadonlyArray<CanonicalTagMetadata>);
    /** Default built-in registry singleton. */
    static readonly default: TaxonomyRegistry;
    /** True when `tag` is a canonical tag. */
    isCanonical(tag: string): boolean;
    /** Look up metadata for a canonical tag. */
    get(tag: string): CanonicalTagMetadata | undefined;
    /** List all canonical tags. */
    list(): ReadonlyArray<CanonicalTagMetadata>;
    /** List tags for a specific axis. */
    listByAxis(axis: TaxonomyAxis): ReadonlyArray<CanonicalTagMetadata>;
    /**
     * Normalize an ad-hoc label to its canonical form.
     *
     * Returns the canonical tag id, or `undefined` if the label has no
     * known canonical mapping.
     */
    normalize(adhoc: string): string | undefined;
    /**
     * Validate that every tag in `tags` is canonical.
     *
     * @param tags - Tags to validate.
     * @returns An array of invalid tags. Empty array = all valid.
     */
    validate(tags: ReadonlyArray<string>): string[];
    /**
     * Validate tags and throw on failure.
     *
     * @param tags - Tags to validate.
     * @param context - Human-readable context for the error message.
     * @throws TaxonomyError when any tag is not canonical.
     */
    validateOrThrow(tags: ReadonlyArray<string>, context: string): void;
    /**
     * Normalize a set of ad-hoc labels to canonical form.
     *
     * Unknown labels are passed through unchanged (they may be
     * project-specific extensions or task-id references).
     *
     * @param labels - Ad-hoc labels to normalize.
     * @returns Normalized label set (deduplicated).
     */
    normalizeSet(labels: ReadonlyArray<string>): string[];
}
//# sourceMappingURL=taxonomy.d.ts.map