import { Effect, Schema } from "effect";
import type { ParseOptions } from "effect/SchemaAST";
import { AgentManifest, type PinnedAgent } from "./agent-manifest.js";
import { ProgramManifest, type PinnedProgram } from "./program-manifest.js";
import { AgentPin, ProgramPin } from "./pin.js";
/** @experimental One complete pinned Agent entry in an executable closure. */
export interface AgentEntry {
    readonly _tag: "Agent";
    readonly pin: AgentPin;
    readonly manifest: AgentManifest;
}
/** @experimental One complete pinned Agent Program entry in an executable closure. */
export interface ProgramEntry {
    readonly _tag: "Program";
    readonly pin: ProgramPin;
    readonly manifest: ProgramManifest;
}
/** @experimental One exact executable definition in a closed closure. */
export type ExecutableEntry = AgentEntry | ProgramEntry;
/** @experimental One globally pinned child profile available by selection name. */
export interface ProfileBinding {
    readonly selection: string;
    readonly agent: AgentPin;
}
/** @experimental Exact active executable within one closed closure. */
export declare const ExecutableTarget: Schema.Union<readonly [Schema.brand<Schema.String, "@batonfx/core/agent-pin">, Schema.brand<Schema.String, "@batonfx/core/program-pin">]>;
/** @experimental */
export type ExecutableTarget = typeof ExecutableTarget.Type;
/** @experimental Complete closed executable profile registry and entry closure. */
export interface ExecutableManifest {
    readonly version: "2";
    readonly root: ExecutableTarget;
    readonly profiles: ReadonlyArray<ProfileBinding>;
    readonly entries: ReadonlyArray<ExecutableEntry>;
}
/** @experimental Durable reference to one exact executable closure and active Agent. */
export declare const ExecutableRef: Schema.Struct<{
    readonly executable: Schema.brand<Schema.String, "@batonfx/core/executable-pin">;
    readonly active: Schema.Union<readonly [Schema.brand<Schema.String, "@batonfx/core/agent-pin">, Schema.brand<Schema.String, "@batonfx/core/program-pin">]>;
}>;
/** @experimental */
export type ExecutableRef = typeof ExecutableRef.Type;
/** @experimental Executable closure paired with its constructor-owned reference. */
export interface PinnedExecutable {
    readonly ref: ExecutableRef;
    readonly manifest: ExecutableManifest;
}
export interface AgentEntryEncoded extends Omit<AgentEntry, "pin" | "manifest"> {
    readonly pin: string;
    readonly manifest: typeof AgentManifest.Encoded;
}
export interface ProgramEntryEncoded extends Omit<ProgramEntry, "pin" | "manifest"> {
    readonly pin: string;
    readonly manifest: typeof ProgramManifest.Encoded;
}
export type ExecutableEntryEncoded = AgentEntryEncoded | ProgramEntryEncoded;
export interface ProfileBindingEncoded extends Omit<ProfileBinding, "agent"> {
    readonly agent: string;
}
export interface ExecutableManifestEncoded extends Omit<ExecutableManifest, "root" | "profiles" | "entries"> {
    readonly root: string;
    readonly profiles: ReadonlyArray<ProfileBindingEncoded>;
    readonly entries: ReadonlyArray<ExecutableEntryEncoded>;
}
export interface PinnedExecutableEncoded extends Omit<PinnedExecutable, "ref" | "manifest"> {
    readonly ref: typeof ExecutableRef.Encoded;
    readonly manifest: ExecutableManifestEncoded;
}
/** @experimental One complete pinned Agent entry in an executable closure. */
export declare const AgentEntry: Schema.Codec<AgentEntry, AgentEntryEncoded>;
/** @experimental One complete pinned Agent Program entry in an executable closure. */
export declare const ProgramEntry: Schema.Codec<ProgramEntry, ProgramEntryEncoded>;
/** @experimental One exact executable definition in a closed closure. */
export declare const ExecutableEntry: Schema.Codec<ExecutableEntry, ExecutableEntryEncoded>;
/** @experimental One globally pinned child profile available by selection name. */
export declare const ProfileBinding: Schema.Codec<ProfileBinding, ProfileBindingEncoded>;
/** @experimental Complete closed executable profile registry and entry closure. */
export declare const ExecutableManifest: Schema.Codec<ExecutableManifest, ExecutableManifestEncoded>;
/** @experimental Construct, validate, canonicalize, and pin a complete executable closure. */
export declare const make: (input: {
    readonly root: ExecutableTarget;
    readonly active?: ExecutableTarget;
    readonly profiles?: ReadonlyArray<ProfileBinding>;
    readonly entries: ReadonlyArray<({
        readonly _tag: "Agent";
    } & PinnedAgent) | ({
        readonly _tag: "Program";
    } & PinnedProgram)>;
}) => PinnedExecutable;
/** @experimental Canonical executable fixture for tests and non-running documentation examples. */
export declare const makeTest: {
    (revision?: string): (name: string) => PinnedExecutable;
    (name: string, revision?: string): PinnedExecutable;
};
/** @experimental Verify that a durable reference is exactly owned by a closure. */
export declare const validateRef: {
    (manifest: ExecutableManifest): (ref: ExecutableRef) => void;
    (ref: ExecutableRef, manifest: ExecutableManifest): void;
};
/** @experimental Encode one constructor-validated executable authority. */
export declare const encode: {
    (input: PinnedExecutable, options?: ParseOptions): Effect.Effect<PinnedExecutableEncoded, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: PinnedExecutable) => Effect.Effect<PinnedExecutableEncoded, Schema.SchemaError, never>;
};
/** @experimental Decode and verify one complete pinned executable authority. */
export declare const decode: (input: unknown) => Effect.Effect<PinnedExecutable, Schema.SchemaError | import("effect/Cause").UnknownError, never>;