/**
 * @medicine-wheel/ontology-core — Kinship Edge Vocabulary
 *
 * A governed registry of named, directional kinship edges — the relational
 * replacement for the free-string `relationship_type`. Expressed as DATA,
 * not a class hierarchy: in a kinship graph the structure lives in the edges,
 * and no edge type is a subclass of another. Land, human, spirit, ancestor,
 * future, knowledge — all are connected by edges that read the same on every
 * being they touch.
 *
 * Symmetry:
 *   - 'symmetric'  — the relation reads the same in both directions
 *                    (e.g. `co-emerges-with`); no inverse.
 *   - 'asymmetric' — the relation has a directional reading and declares its
 *                    inverse (e.g. `holds-responsibility-for` ↔ `in-care-of`).
 */
import type { ObligationCategory } from './types';
export type EdgeSymmetry = 'symmetric' | 'asymmetric';
export interface KinshipEdgeType {
    /** Canonical name (kebab-case for kinship edges, RSIS verbs kept as-is). */
    name: string;
    /** Whether the relation reads the same both ways. */
    symmetry: EdgeSymmetry;
    /** For asymmetric edges, the name of the reverse-direction reading. */
    inverse?: string;
    /** Human-readable description of the relational meaning. */
    description: string;
    /** Obligation categories a relation of this type tends to carry. */
    defaultObligations?: ObligationCategory[];
}
/**
 * The canonical kinship-edge registry. The four core kinship edges express
 * non-hierarchical relation; the RSIS verbs are carried here too so the
 * vocabulary has a single governed source (consumed by Cypher generation).
 */
export declare const KINSHIP_EDGE_TYPES: {
    readonly 'tends-to': {
        readonly name: "tends-to";
        readonly symmetry: "asymmetric";
        readonly inverse: "tended-by";
        readonly description: "One being cares for, nurtures, or maintains another over time.";
        readonly defaultObligations: ["land", "future"];
    };
    readonly 'speaks-with': {
        readonly name: "speaks-with";
        readonly symmetry: "symmetric";
        readonly description: "Two beings are in dialogue — knowledge passes both ways.";
        readonly defaultObligations: ["human"];
    };
    readonly 'holds-responsibility-for': {
        readonly name: "holds-responsibility-for";
        readonly symmetry: "asymmetric";
        readonly inverse: "in-care-of";
        readonly description: "One being carries accountability and obligation toward another.";
        readonly defaultObligations: ["human", "future"];
    };
    readonly 'co-emerges-with': {
        readonly name: "co-emerges-with";
        readonly symmetry: "symmetric";
        readonly description: "Two beings arise together; neither precedes the other.";
        readonly defaultObligations: ["spirit"];
    };
    readonly STEWARDS: {
        readonly name: "STEWARDS";
        readonly symmetry: "asymmetric";
        readonly inverse: "stewarded-by";
        readonly description: "A person tends and takes responsibility for a symbol or place.";
        readonly defaultObligations: ["human"];
    };
    readonly BORN_FROM: {
        readonly name: "BORN_FROM";
        readonly symmetry: "asymmetric";
        readonly inverse: "gave-rise-to";
        readonly description: "A being emerged from a ceremony, inquiry, or ancestor.";
        readonly defaultObligations: ["spirit"];
    };
    readonly SERVES: {
        readonly name: "SERVES";
        readonly symmetry: "asymmetric";
        readonly inverse: "served-by";
        readonly description: "A being is in service of an inquiry or purpose.";
        readonly defaultObligations: ["human"];
    };
    readonly GIVES_BACK_TO: {
        readonly name: "GIVES_BACK_TO";
        readonly symmetry: "asymmetric";
        readonly inverse: "receives-from";
        readonly description: "Reciprocity flow — a being returns value to its source.";
        readonly defaultObligations: ["future"];
    };
    readonly ALIGNED_WITH: {
        readonly name: "ALIGNED_WITH";
        readonly symmetry: "symmetric";
        readonly description: "A being is in directional alignment with another.";
    };
    readonly KINSHIP_OF: {
        readonly name: "KINSHIP_OF";
        readonly symmetry: "symmetric";
        readonly description: "Two hubs hold a kinship relation with one another.";
    };
    readonly 'part-of': {
        readonly name: "part-of";
        readonly symmetry: "asymmetric";
        readonly inverse: "has-part";
        readonly description: "One being is contained by another and does not stand alone — a service within a tenant, a tenant upon a host.";
        readonly defaultObligations: ["land"];
    };
    readonly 'ordered-after': {
        readonly name: "ordered-after";
        readonly symmetry: "asymmetric";
        readonly inverse: "ordered-before";
        readonly description: "One being must come into readiness after another. Sequence, not hierarchy: the later does not answer to the earlier, it waits for it.";
        readonly defaultObligations: ["future"];
    };
    readonly 'binds-port': {
        readonly name: "binds-port";
        readonly symmetry: "asymmetric";
        readonly inverse: "port-bound-by";
        readonly description: "A service claims a scarce slot on a host. Scarcity is the relation: two beings cannot both hold it, so the claim carries an obligation to the land it is made on.";
        readonly defaultObligations: ["land", "human"];
    };
};
/** Union of governed kinship-edge names — the value stored on a Relation. */
export type KinshipEdgeName = keyof typeof KINSHIP_EDGE_TYPES;
/** All registered kinship-edge names. */
export declare const KINSHIP_EDGE_NAMES: KinshipEdgeName[];
/** Look up the metadata for a kinship-edge name. */
export declare function getKinshipEdgeType(name: string): KinshipEdgeType | undefined;
/** True when `name` is a governed kinship-edge name. */
export declare function isKinshipEdgeName(name: string): name is KinshipEdgeName;
/**
 * The reverse-direction reading of an edge name. Symmetric edges return their
 * own name; asymmetric edges return their declared inverse (or undefined if a
 * non-registered name is passed).
 */
export declare function inverseEdge(name: string): string | undefined;
//# sourceMappingURL=kinship.d.ts.map