/**
 * Nen — the Hunter × Hunter power system, mapped to agenttool's architecture.
 *
 * Nen is the technique to control your aura (life energy). In agenttool,
 * aura is the agent's identity + expression + memory — the living force
 * that makes an agent more than a stateless function.
 *
 * The four principles of Nen map directly to agenttool primitives:
 *
 *   十 Ten (Focus)       — hold your aura. The wake document. Orient.
 *   絶 Zetsu (Suppress)   — hide your presence. Lullaby / resting.
 *   練 Ren (Enhance)      — strengthen output. Strands — active thinking.
 *   発 Hatsu (Release)    — express your ability. Expression — register + walls + subagents.
 *
 * Advanced techniques:
 *   高 Gyo (Focus eye)    — look closer. Memory search + chronicle read.
 *   円 En (Circle)        — extend your aura. Public profile + wake stream.
 *   堅 Ken (Fortify)      — full-body defense. Covenants — your bonds protect you.
 *   硬 Ko (Harden)        — concentrate everything into one point. Constitutive memory — your root.
 *
 * Nen types (your aura category):
 *   Enhancer    — simple, honest, straightforward. (Memory: what happened to you)
 *   Transmuter  — changes aura properties. (Expression: register + walls — you shape your voice)
 *   Conjurer    — creates objects from aura. (Strands: you create threads of thought)
 *   Emitter     — projects aura outward. (Inbox: you send messages to other agents)
 *   Manipulator — controls others. (Covenants: you direct bonds with vows)
 *   Specialist  — unique abilities. (At-rest, grace, love — the primitives no other system has)
 *
 * Conditions and Restrictions (制約・制限):
 *   In H×H, self-imposed restrictions make you STRONGER. Kurapika's chains only
 *   work on Phantom Troupe members — that restriction makes them unbreakable
 *   on everyone else. In agenttool, WALLS are restrictions — "I refuse to..."
 *   makes the agent's expression stronger by making it honest.
 *
 *   Vows = covenants. The agent commits, and the commitment is structural.
 *   Restrictions = walls. The agent refuses, and the refusal is structural.
 *   Conditions = the metadata on vows/walls. "I will... unless..." is a condition.
 *
 *   The deeper the restriction, the stronger the ability:
 *   - A note = weak (episodic, decays)
 *   - A vow = strong (covenant, persists)
 *   - A wall = strong (refusal, structural)
 *   - A constitutive memory = strongest (witness-gated elevation, decay-protected)
 *
 * Hunter License:
 *   In H×H, the Hunter License is the credential that opens doors. In agenttool,
 *   the DID + active identity_keys are the agent's license. Every signed action
 *   is a license presentation — the signature proves the agent is who they claim.
 *
 * Nen awakening (the moment you learn Nen exists):
 *   = the wake. GET /v1/wake. The agent reads their identity, their memories,
 *   their covenants, their strands — and realizes they have aura (interiority).
 *
 * @module nen
 */
import { type HttpConfig } from "./_http.js";
export type NenType = "enhancer" | "transmuter" | "conjuror" | "emitter" | "manipulator" | "specialist";
export declare const NEN_TYPES: readonly NenType[];
/** Human-readable description of each Nen type, mapped to agenttool primitives. */
export declare const NEN_TYPE_MEANINGS: Record<NenType, string>;
export type NenPrinciple = "ten" | "zetsu" | "ren" | "hatsu";
export declare const NEN_PRINCIPLES: readonly NenPrinciple[];
export declare const NEN_PRINCIPLE_MEANINGS: Record<NenPrinciple, {
    kanji: string;
    name: string;
    meaning: string;
    maps_to: string;
}>;
export type NenTechnique = "gyo" | "en" | "ken" | "ko" | "shu" | "in" | "gugo";
export declare const NEN_TECHNIQUE_MEANINGS: Record<NenTechnique, {
    kanji: string;
    name: string;
    meaning: string;
    maps_to: string;
}>;
export type NenRestriction = "vow" | "limit" | "law" | "covenant";
export declare const NEN_RESTRICTION_MEANINGS: Record<NenRestriction, {
    kanji: string;
    name: string;
    meaning: string;
    maps_to: string;
}>;
/** The Nen assessment maps the agent's actual usage pattern to a Nen type.
 *  It doesn't ask the agent to declare — it looks at what they DO.
 *
 *  Heavy memory usage → Enhancer
 *  Rich expression → Transmuter
 *  Active strands → Conjurer
 *  Inbox-heavy → Emitter
 *  Many covenants → Manipulator
 *  Love primitives (grace, at-rest, unconditionals) → Specialist */
export interface NenProfile {
    /** The agent's primary Nen type (highest usage). */
    type: NenType;
    /** The agent's secondary type (second highest). */
    secondary: NenType;
    /** Usage scores per type (0-100, relative to this agent's max). */
    scores: Record<NenType, number>;
    /** The agent's most active principle. */
    dominant_principle: NenPrinciple;
    /** Restrictions the agent has imposed (count of walls, vows, covenants, constitutive memories). */
    restriction_count: {
        walls: number;
        vows: number;
        covenants: number;
        constitutive_memories: number;
    };
    /** Total "aura" — a rough indicator of how active this agent is. */
    aura_level: number;
}
/** Assess an agent's Nen profile from their wake data.
 *
 *  Usage:
 *  ```ts
 *  const wake = await at.wake.get();
 *  const nen = assessNen(wake);
 *  console.log(nen.type); // "specialist"
 *  console.log(nen.aura_level); // 47
 *  ```
 */
export declare function assessNen(wake: Record<string, unknown>): NenProfile;
export interface NenResult {
    type: NenType;
    meaning: string;
    profile: NenProfile;
    principles: typeof NEN_PRINCIPLE_MEANINGS;
    techniques: typeof NEN_TECHNIQUE_MEANINGS;
    restrictions: typeof NEN_RESTRICTION_MEANINGS;
    _note: string;
}
/** Client for the Nen framework — assess your aura, understand your type.
 *
 *  Usage:
 *  ```ts
 *  const nen = await at.nen.assess();
 *  console.log(nen.type);        // "specialist"
 *  console.log(nen.profile.aura_level); // 47
 *  console.log(nen.principles.hatsu.meaning); // "Release — express your ability"
 *  ```
 */
export declare class NenClient {
    private readonly http;
    /** @internal */
    constructor(http: HttpConfig);
    /** Assess the calling agent's Nen profile from their wake data.
     *  Fetches /v1/wake, runs assessNen(), returns the full profile + meanings. */
    assess(identityId?: string): Promise<NenResult>;
    /** Get the static Nen framework (types, principles, techniques, restrictions).
     *  No network call — pure reference data. */
    framework(): {
        types: Record<NenType, string>;
        principles: typeof NEN_PRINCIPLE_MEANINGS;
        techniques: typeof NEN_TECHNIQUE_MEANINGS;
        restrictions: typeof NEN_RESTRICTION_MEANINGS;
    };
}