/**
 * Shared projection helper: composes installed/active/unmanaged from
 * declared/resolved/actual plus the installed-pack set.
 *
 * Per the projection invariant in the workspace read-model design (Decision 7):
 *
 * ```ts
 * direct = declared.map(withInstallationOrigin("direct"));
 * implicit = installedPacks
 *   .flatMap(p => p.members)
 *   .filter(notDeclaredByName) // direct (incl. disabled) wins
 *   .map(withInstallationOrigin("pack-member"));
 * installed = direct + implicit;
 * active = installed.filter(activation === "enabled");
 * unmanaged = actual
 *   .filter(notClaimedByInstalled)
 *   .filter(notClaimedBySubjectPolicy);
 * ```
 *
 * The helper owns:
 * - direct-over-pack precedence;
 * - disabled-direct still claims actual occurrences (excluded from active and
 *   from unmanaged);
 * - actual-occurrence attachment via `policy.attachActualToInstalled`;
 * - orphaned-resolved diagnostics — resolved entries with no direct or
 *   pack-member home publish a warning;
 * - deterministic name-sorted ordering.
 *
 * The helper does NOT own subject row shape or subject policy. Both come in as
 * parameters via `SubjectPolicy<...>`.
 */
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import type { Diagnostics, Warning } from "../diagnostics.js";
import type { LockfileReadError, SettingsReadError } from "../errors.js";
import type { ActivationState, InstallationOrigin, InstalledPackRef } from "../types.js";
import { type RowWithKey } from "./indexByName.js";
/**
 * One entry within a subject's `declared` payload. The shape is opaque to the
 * helper; the policy callbacks bridge to subject internals.
 */
export type TDeclaredEntry<TDeclared> = TDeclared extends ReadonlyArray<infer E> ? E : TDeclared;
/** One entry within a subject's `resolved` payload. */
export type TResolvedEntry<TResolved> = TResolved extends ReadonlyArray<infer E> ? E : TResolved;
/** One actual occurrence within a subject's `actual` payload. */
export type TActualEntry<TActual> = TActual extends ReadonlyArray<infer E> ? E : TActual;
/**
 * Subject-specific policy callbacks the projection helper requires.
 */
export interface SubjectPolicy<TDeclared, TResolved, TActual, TPackMember, TInstalled, TUnmanaged> {
    /** Iterate the subject's declared entries from a decoded `declared` payload. */
    readonly declaredEntries: (declared: TDeclared) => ReadonlyArray<TDeclaredEntry<TDeclared>>;
    /** Extract the subject name from a declared entry. */
    readonly declaredName: (entry: TDeclaredEntry<TDeclared>) => string;
    /**
     * Activation state derived from a declared entry.
     */
    readonly declaredActivation: (entry: TDeclaredEntry<TDeclared>) => ActivationState;
    /** Iterate the subject's resolved entries from a decoded `resolved` payload. */
    readonly resolvedEntries: (resolved: TResolved) => ReadonlyArray<TResolvedEntry<TResolved>>;
    /** Extract the subject name from a resolved entry. */
    readonly resolvedName: (entry: TResolvedEntry<TResolved>) => string;
    /** Iterate the subject's actual occurrences from an `actual` payload. */
    readonly actualEntries: (actual: TActual) => ReadonlyArray<TActualEntry<TActual>>;
    /** Extract the subject name from an actual occurrence. */
    readonly actualName: (entry: TActualEntry<TActual>) => string;
    /** Extract the subject name from a pack-member entry. */
    readonly packMemberName: (member: TPackMember) => string;
    /** Activation state for a pack-member installed row. */
    readonly packMemberActivation: (member: TPackMember) => ActivationState;
    /** Filter actual occurrences to those that match a given installed name. */
    readonly attachActualToInstalled: (name: string, actual: ReadonlyArray<TActualEntry<TActual>>) => ReadonlyArray<TActualEntry<TActual>>;
    /**
     * Subject-policy filter for unmanaged actual occurrences. Returns `true` if
     * the occurrence is NOT claimed by subject-specific policy.
     */
    readonly notClaimedBySubjectPolicy: (entry: TActualEntry<TActual>) => boolean;
    /** Build a subject installed row from the assembled facts. */
    readonly buildInstalledRow: (input: BuildInstalledRowInput<TDeclared, TResolved, TActual, TPackMember>) => TInstalled;
    /** Build a subject unmanaged row from one actual occurrence. */
    readonly buildUnmanagedRow: (entry: TActualEntry<TActual>) => TUnmanaged;
    /** Build the orphan-resolved warning published when a resolved entry has no home. */
    readonly resolvedOrphanWarning: (name: string) => Warning;
}
/**
 * Input passed to `buildInstalledRow`. Carries everything the subject needs
 * to construct its installed row.
 */
export interface BuildInstalledRowInput<TDeclared, TResolved, TActual, TPackMember> {
    readonly name: string;
    readonly installationOrigin: InstallationOrigin<TDeclaredEntry<TDeclared>, TPackMember>;
    readonly activation: ActivationState;
    readonly resolved: Option.Option<TResolvedEntry<TResolved>>;
    readonly actual: ReadonlyArray<TActualEntry<TActual>>;
    readonly providingPacks: ReadonlyArray<InstalledPackRef>;
}
export interface ProjectInstalledExtensionsInput<TDeclared, TResolved, TActual, TPack, TPackMember, TInstalled, TUnmanaged> {
    readonly declared: Effect.Effect<Option.Option<TDeclared>, SettingsReadError>;
    readonly resolved: Effect.Effect<Option.Option<TResolved>, LockfileReadError>;
    readonly actual: Effect.Effect<TActual>;
    readonly installedPacks: Effect.Effect<ReadonlyArray<TPack>, SettingsReadError | LockfileReadError>;
    readonly packMembers: (pack: TPack) => ReadonlyArray<TPackMember>;
    readonly packRef: (pack: TPack) => InstalledPackRef;
    readonly policy: SubjectPolicy<TDeclared, TResolved, TActual, TPackMember, TInstalled, TUnmanaged>;
    readonly diagnostics: Diagnostics;
}
export interface ProjectInstalledExtensionsOutput<TInstalled, TUnmanaged> {
    readonly installed: ReadonlyArray<TInstalled>;
    readonly active: ReadonlyArray<TInstalled>;
    readonly unmanaged: ReadonlyArray<TUnmanaged>;
}
export declare const makeProjectedSubjectCells: <TDeclaredEntry extends {
    readonly name: string;
}, TDeclared extends ReadonlyArray<TDeclaredEntry>, TResolved, TActual, TInstalled extends RowWithKey, TUnmanaged>(args: {
    readonly declared: Effect.Effect<Option.Option<TDeclared>, SettingsReadError>;
    readonly resolved: Effect.Effect<Option.Option<TResolved>, LockfileReadError>;
    readonly actual: Effect.Effect<TActual>;
    readonly project: Effect.Effect<ProjectInstalledExtensionsOutput<TInstalled, TUnmanaged>, SettingsReadError | LockfileReadError>;
}) => {
    declared: Effect.Effect<Option.Option<TDeclared>, SettingsReadError, never>;
    resolved: Effect.Effect<Option.Option<TResolved>, LockfileReadError, never>;
    actual: Effect.Effect<TActual, never, never>;
    installed: Effect.Effect<readonly TInstalled[], SettingsReadError | LockfileReadError, never>;
    byName: (name: string) => Effect.Effect<Option.Option<TInstalled>, SettingsReadError | LockfileReadError, never>;
    declaredByName: (name: string) => Effect.Effect<Option.Option<Exclude<TDeclaredEntry, undefined>>, SettingsReadError, never>;
    active: Effect.Effect<readonly TInstalled[], SettingsReadError | LockfileReadError, never>;
    unmanaged: Effect.Effect<readonly TUnmanaged[], SettingsReadError | LockfileReadError, never>;
};
/**
 * Compose installed, active, and unmanaged rows from declared/resolved/actual
 * plus the installed-pack set, per the projection invariant.
 *
 * Source-read failures propagate so invalid persisted authority is never
 * treated as absent.
 */
export declare const projectInstalledExtensions: <TDeclared, TResolved, TActual, TPack, TPackMember, TInstalled, TUnmanaged>(input: ProjectInstalledExtensionsInput<TDeclared, TResolved, TActual, TPack, TPackMember, TInstalled, TUnmanaged>) => Effect.Effect<ProjectInstalledExtensionsOutput<TInstalled, TUnmanaged>, SettingsReadError | LockfileReadError>;
//# sourceMappingURL=projection.d.ts.map