/**
 * `totem init --doctrine` — wire the cohort parity manifest into a consumer.
 *
 * Proposal 292 §10 (mmnto-ai/totem-strategy#548), build-slice S1. Under
 * emitter-B the strategy-canonical `parity-manifest.yaml` is distributed as a
 * private package (`@mmnto/strategy-doctrine`, npmjs-private); totem-core's
 * whole job is to point `orient.parityManifest` at the installed pin. The
 * consumer adds the pin dependency explicitly (the opt-in); this command writes
 * ONLY the config pointer — never `package.json`, never the manifest, never the
 * reader (the parity reader / honest-absent SKIP / `configured` self-gate
 * already ship, mmnto-ai/totem#2085). No pin installed ⇒ honest-absent: guide,
 * write nothing, exit 0.
 *
 * **Detection is parse-based, insertion is conservative** (bot review on #2089):
 * "already set" and "does an `orient` block exist" are read from the *parsed*
 * config (`loadConfig`) — ground truth, so comments, strings, quoted keys, and
 * nested objects can never produce a false positive. The only auto-edit is
 * adding a brand-new top-level `orient` field to a canonical `export default {`
 * config; any existing `orient` block or non-canonical shape bails to a
 * format-aware manual snippet rather than risk a wrong edit (Tenet 4).
 */
/** The private package carrying the strategy-canonical parity manifest snapshot. */
export declare const DOCTRINE_PIN_PACKAGE = "@mmnto/strategy-doctrine";
/**
 * Repo-root-relative path the config pointer is set to. Resolves through the
 * node_modules pin (pnpm's direct-dep symlink included) the same way the parity
 * reader resolves `orient.parityManifest` — zero-network, riding the install
 * that already ran (Tenet 6).
 */
export declare const DOCTRINE_MANIFEST_RELPATH = "node_modules/@mmnto/strategy-doctrine/parity-manifest.yaml";
/** Result of the pure top-level-orient insertion. */
export type InsertOrientResult = {
    kind: 'written';
    content: string;
} | {
    kind: 'unspliceable';
};
/**
 * Insert a NEW top-level `orient: { parityManifest }` field just after the sole
 * `export default {` of a TS/JS config. Called ONLY when the parsed config has
 * no `orient` key (detection is parse-based upstream), so there is no merge to
 * perform and no risk of a duplicate key. Conservative by construction: a
 * config without exactly one real (non-string, non-comment) `export default {`
 * declaration bails to `unspliceable` so the caller falls back to the manual
 * snippet. Never a wrong edit (Tenet 4).
 */
export declare function insertTopLevelOrient(configContent: string, manifestPath: string): InsertOrientResult;
/** The single field line to add inside an existing `orient` block, by config format. */
export declare function doctrineFieldSnippet(manifestPath: string, ext: string): string;
/** The full `orient` block to add at the config's top level, by config format. */
export declare function doctrineBlockSnippet(manifestPath: string, ext: string): string;
/** Structured outcome of the wiring flow; the caller maps each to UI + exit.
 *  Parse / read / write FAILURES are not outcomes — they throw a `TotemError`
 *  (with `cause`) from inside `wireDoctrineManifest` (the `.gemini/styleguide`
 *  CLI-layer error convention). */
export type DoctrineWireOutcome = {
    kind: 'pin-absent';
    manifestPath: string;
} | {
    kind: 'no-config';
} | {
    kind: 'global-only';
} | {
    kind: 'already-set';
    configPath: string;
} | {
    kind: 'manual';
    configPath: string;
    snippet: string;
    reason: 'orient-exists' | 'no-splice-point';
} | {
    kind: 'written';
    configPath: string;
    manifestPath: string;
};
/**
 * Detect the doctrine pin and wire (or honest-absent-skip) the config pointer.
 * Takes `cwd` (and an optional `homeDir`) explicitly so it is testable without
 * `process.chdir`, mirroring the parity reader's cwd-in signature.
 */
export declare function wireDoctrineManifest(cwd: string, homeDir?: string): Promise<DoctrineWireOutcome>;
//# sourceMappingURL=init-doctrine.d.ts.map