/**
 * Knowledge subject module: declared/resolved/actual payloads, scanner
 * composition, and projections via the shared helper.
 *
 * Declared bundles come from `settings.knowledge`; resolved bundles come from
 * `axm-lock.yaml` `knowledge`. Actual occurrences come exclusively from the
 * canonical-extensions scanner (`type === "knowledge"`), which enumerates
 * project-authored `knowledge/<name>/src`, project-acquired
 * `agent_extensions/<source>/<source-full-name>`, and user-scope packages.
 *
 * Knowledge installs also write two derived artifacts — the `.axm/knowledge/index.md`
 * catalog and the discovery region inside the agent instructions file. Both live
 * outside canonical package roots, so the canonical scanner never sees them and they
 * cannot become occurrences; `actual` is therefore scoped to the materialized
 * bundle package directory by construction.
 *
 * Pack-resolved Knowledge members participate in the same direct-over-pack
 * projection as every other extension type.
 */
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import { type ExtensionName } from "../../../extensions/common.js";
import type { KnowledgeLockEntry, Lockfile } from "../../../lockfile/schema.js";
import type { KnowledgeEntry, Settings } from "../../../settings/schema.js";
import type { Diagnostics } from "../diagnostics.js";
import type { LockfileReadError, SettingsReadError } from "../errors.js";
import type { CanonicalExtensionOccurrence } from "../scanners/types.js";
import type { ActivationState, ExtensionKey, InstallationOrigin, InstalledPackRef, Scope } from "../types.js";
export type KnowledgeDetectionOrigin = {
    readonly _tag: "canonical-axm-knowledge";
} | {
    readonly _tag: "external-axm-knowledge";
};
export interface DeclaredKnowledgeBundle {
    readonly name: ExtensionName;
    readonly entry: KnowledgeEntry;
}
export type DeclaredKnowledge = ReadonlyArray<DeclaredKnowledgeBundle>;
export interface ResolvedKnowledgeBundle {
    readonly name: ExtensionName;
    readonly lockEntry: KnowledgeLockEntry;
}
export type ResolvedKnowledge = ReadonlyArray<ResolvedKnowledgeBundle>;
export interface ActualKnowledgeBundle {
    readonly key: ExtensionKey<"knowledge">;
    readonly origin: KnowledgeDetectionOrigin;
    readonly contentRoot: string;
    readonly packageRoot: string | null;
}
export type ActualKnowledge = ReadonlyArray<ActualKnowledgeBundle>;
export interface KnowledgePackMember {
    readonly name: ExtensionName;
    readonly providingPack: InstalledPackRef;
}
export interface InstalledKnowledgeBundle {
    readonly key: ExtensionKey<"knowledge">;
    readonly installationOrigin: InstallationOrigin<DeclaredKnowledgeBundle, KnowledgePackMember>;
    readonly activation: ActivationState;
    readonly resolved: Option.Option<ResolvedKnowledgeBundle>;
    readonly actual: ReadonlyArray<ActualKnowledgeBundle>;
    readonly providingPacks: ReadonlyArray<InstalledPackRef>;
}
export interface UnmanagedKnowledgeBundle {
    readonly key: ExtensionKey<"knowledge">;
    readonly actual: ActualKnowledgeBundle;
}
export interface KnowledgeScanners {
    readonly canonical: Effect.Effect<ReadonlyArray<CanonicalExtensionOccurrence>>;
}
export interface KnowledgeScopedLoaders {
    readonly settings: Effect.Effect<Option.Option<Settings>, SettingsReadError>;
    readonly lockfile: Effect.Effect<Option.Option<Lockfile>, LockfileReadError>;
}
export interface KnowledgeExtensionsApiDeps {
    readonly scope: Scope;
    readonly loaders: KnowledgeScopedLoaders;
    readonly scanners: KnowledgeScanners;
    readonly installedPacks: Effect.Effect<ReadonlyArray<InstalledPackForKnowledge>, SettingsReadError | LockfileReadError>;
    readonly diagnostics: Diagnostics;
}
export interface InstalledPackForKnowledge {
    readonly ref: InstalledPackRef;
    readonly knowledge: ReadonlyArray<KnowledgePackMember>;
}
export interface KnowledgeExtensionsApi {
    readonly declared: Effect.Effect<Option.Option<DeclaredKnowledge>, SettingsReadError>;
    readonly resolved: Effect.Effect<Option.Option<ResolvedKnowledge>, LockfileReadError>;
    readonly actual: Effect.Effect<ActualKnowledge>;
    readonly installed: Effect.Effect<ReadonlyArray<InstalledKnowledgeBundle>, SettingsReadError | LockfileReadError>;
    readonly byName: (name: string) => Effect.Effect<Option.Option<InstalledKnowledgeBundle>, SettingsReadError | LockfileReadError>;
    readonly declaredByName: (name: string) => Effect.Effect<Option.Option<DeclaredKnowledgeBundle>, SettingsReadError>;
    readonly active: Effect.Effect<ReadonlyArray<InstalledKnowledgeBundle>, SettingsReadError | LockfileReadError>;
    readonly unmanaged: Effect.Effect<ReadonlyArray<UnmanagedKnowledgeBundle>, SettingsReadError | LockfileReadError>;
}
/**
 * Build the knowledge subject API. Returns an `Effect` because the projection
 * cell is wrapped in `Effect.cached` so the four derived cells share one
 * in-flight execution per scope, mirroring `state.ts`.
 */
export declare const makeKnowledgeExtensionsApi: (deps: KnowledgeExtensionsApiDeps) => Effect.Effect<KnowledgeExtensionsApi>;
//# sourceMappingURL=knowledge.d.ts.map