import { type Command, type Extension, type ExtensionRef, type Registry } from "@cotal-ai/core";
import { type LocalProcess } from "@cotal-ai/workspace";
/** The official first-party runtimes, name → npm package. This is NOT authority — registration is
 *  still explicit (`cotal ext add` installs the package; importing it self-registers the provider).
 *  It is the CLI's UX source of truth so an uninstalled runtime error names a REAL package, a typo
 *  says "unknown" instead of inventing `@cotal-ai/<typo>`, and `cotal runtimes` can list what's one
 *  `cotal ext add` away. A third-party runtime installs under its own package name and, once added,
 *  resolves like any other — it just isn't listed here up front. */
export declare const OFFICIAL_RUNTIMES: Readonly<Record<string, string>>;
/** The host tool each official runtime drives, for `cotal setup` to show before the package is
 *  installed: any one of `names` on PATH counts, and the driver's `override` variable, when set,
 *  names the tool instead. Kept beside {@link OFFICIAL_RUNTIMES} because an uninstalled provider
 *  cannot be asked. */
export declare const OFFICIAL_RUNTIME_TOOLS: Readonly<Record<string, {
    readonly names: readonly string[];
    readonly override?: string;
}>>;
/** Every runtime name the CLI knows about without importing anything: `pty` (built in) + the officials. */
export declare function knownRuntimeNames(): string[];
/** The published binary enables installed-package resolution; library roots retain explicit imports. */
export declare function setInstalledExtensionsEnabled(enabled: boolean): void;
export declare function setCommandSurface(commands: Command[]): void;
export declare function commandSurface(): Command[];
/** Whether this composition root authorizes metadata reads from the installed extension prefix. */
export declare function installedExtensionsEnabled(): boolean;
/** Registered and installed provider names without importing packages (safe for help/completion). */
export declare function extensionNames(kind: string): string[];
/** Base + cached installed process descriptors. No extension package is imported. */
export declare function localProcessSurface(): LocalProcess[];
/** True when this command is a manifest stub that must be materialized before parsing/running. */
export declare function isExtensionStub(cmd: Command): boolean;
/** Overlay the manifest's cached commands onto the registered surface. Returns the combined
 *  command list for help/complete/dispatch. Loud on builtin collisions; never imports. */
export declare function overlayExtensions(reg: Registry): Command[];
/** Swap an extension STUB for its live command: verify the version pin, import the package (it
 *  self-registers), and return the freshly-registered command. Every failure is loud and names
 *  the package. */
export declare function materializeExtensionCommand(stub: Command): Promise<Command>;
/** Resolve a provider, lazily importing the installed package that advertised it when necessary.
 *  The registered short-circuit and the composition-root gate stay here (CLI process state); the
 *  actual manifest read + transactional import is the shared workspace primitive. */
export declare function materializeExtension<T extends Extension = Extension>(ref: ExtensionRef): Promise<T>;
/** Resolve and probe an extension runtime before a manifest command mutates local or mesh state. */
export declare function preflightRuntime(name: string): Promise<void>;
//# sourceMappingURL=ext-loader.d.ts.map