/** Shared list command shell; each type supplies its own rows and document. */
import * as Effect from "effect/Effect";
import type * as Schema from "effect/Schema";
import { Command } from "effect/cli";
import type { InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
import { type ExtensionInventory } from "@agentxm/workspace-kernel/workspace-state";
import type { TypeListResult } from "@agentxm/workspace-features/inspection";
import { type ExpectedCliError } from "../../cli-runtime/index.js";
import { type ViewColumn } from "../../screen/index.js";
interface ListDefinition<Row, S extends Schema.Top, E extends ExpectedCliError, R> {
    readonly type: InstallableExtensionType;
    readonly query: (agents: ReadonlyArray<string>) => Effect.Effect<{
        readonly document: Schema.Schema.Type<S>;
        readonly rows: ReadonlyArray<Row>;
    }, E, R>;
    readonly schema: S;
    readonly columns: ReadonlyArray<ViewColumn<Row>>;
    readonly summary: (document: Schema.Schema.Type<S>, rows: ReadonlyArray<Row>) => string;
    readonly agentFilter: boolean;
}
export declare const inventoryList: <Row, E, R>(type: InstallableExtensionType, list: (agents: ReadonlyArray<string>) => Effect.Effect<TypeListResult<Row>, E, R>) => {
    query: (agents: ReadonlyArray<string>) => Effect.Effect<{
        document: {
            readonly items: readonly {
                readonly name: string;
                readonly type: "hook" | "skill" | "subagent" | "mcp-server" | "rule" | "knowledge" | "pack";
                readonly scope: "user" | "project";
                readonly agentOutcomes: readonly {
                    readonly name: string;
                    readonly reason: string;
                    readonly extensionType: "hook" | "skill" | "subagent" | "mcp-server" | "rule" | "knowledge" | "pack";
                    readonly agentId: string;
                    readonly outcome: "blocked" | "failed" | "projected" | "current" | "not-applicable" | "unsupported";
                    readonly reasonCode: string;
                    readonly path?: string | undefined;
                    readonly mechanism?: string | undefined;
                    readonly nativeUnitKeys?: readonly string[] | undefined;
                    readonly hook?: {
                        readonly implementationId: string;
                        readonly protocol: string;
                        readonly bindings: readonly {
                            readonly id: string;
                            readonly event: string;
                            readonly runtime: string;
                            readonly entrypoint: string;
                            readonly requiredOutcomes: readonly string[];
                            readonly requiredOperations: readonly string[];
                            readonly matcher?: string;
                        }[];
                        readonly conditions: readonly string[];
                        readonly configuration: {
                            readonly status: "valid" | "invalid" | "not-evaluated";
                            readonly fields: readonly {
                                readonly key: string;
                                readonly source: "default" | "consumer" | "unset";
                                readonly value: string | number | boolean | null;
                                readonly redacted: boolean;
                            }[];
                            readonly issues: readonly {
                                readonly key: string;
                                readonly message: string;
                            }[];
                        };
                        readonly runtimeAvailability: "unverified";
                        readonly nativeInvocation: "not-observed";
                        readonly fixtureEvidence: {
                            readonly reason: string;
                            readonly state: "absent" | "invalid" | "stale" | "historical";
                            readonly receipt?: {
                                readonly kind: "fixture-execution";
                                readonly package: string;
                                readonly version: string;
                                readonly contentHash: string;
                                readonly configurationHash: string;
                                readonly startedAt: number;
                                readonly completedAt: number;
                                readonly cwd: "package-root";
                                readonly scope: "user" | "project";
                                readonly platform: {
                                    readonly os: string;
                                    readonly architecture: string;
                                };
                                readonly environment: readonly string[];
                                readonly environmentFreshness: "historical-only";
                                readonly nativeInvocation: "not-observed";
                                readonly sandboxed: false;
                                readonly fixtures: readonly {
                                    readonly fixture: string;
                                    readonly implementation: string;
                                    readonly binding: string;
                                    readonly protocol: string;
                                    readonly runtime: string;
                                    readonly runtimeVersion: string | null;
                                    readonly outcome: "failed" | "passed";
                                    readonly expectedExitCode: number;
                                    readonly observedExitCode: number | null;
                                    readonly stdoutMatches: boolean | null;
                                    readonly stderrMatches: boolean | null;
                                    readonly detail: string;
                                }[];
                                readonly passed: boolean;
                                readonly receiptPath: string;
                            };
                        };
                    };
                }[];
                readonly agents: readonly string[];
                readonly enabled: boolean | null;
                readonly paths: readonly string[];
                readonly classification: {
                    readonly kind: "lifecycle";
                    readonly lifecycle: "unmanaged" | "configured" | "implicit" | "leftover" | "undeclared";
                };
                readonly installed: boolean;
                readonly origins: readonly string[];
                readonly status?: string;
                readonly owner?: string;
                readonly version?: string;
                readonly source?: string;
                readonly nativeLocations?: readonly {
                    readonly state: "unchanged" | "blocked" | "retained" | "created" | "updated" | "removed" | "absent" | "unverified";
                    readonly aliases: readonly string[];
                    readonly scope: "user" | "project";
                    readonly address: {
                        readonly kind: "entry";
                        readonly path: string;
                    } | {
                        readonly kind: "key-path";
                        readonly path: string;
                        readonly keys: readonly [string, ...string[]];
                    } | {
                        readonly kind: "region";
                        readonly path: string;
                        readonly region: string;
                    } | {
                        readonly kind: "file";
                        readonly path: string;
                    };
                    readonly configuredConsumers: readonly string[];
                    readonly potentialReaders: readonly string[];
                    readonly policyReasons: readonly string[];
                    readonly ownership: "absent" | "unverified" | "owned" | "unowned";
                    readonly availability: readonly {
                        readonly agentId: string;
                        readonly state: "unavailable" | "unverified" | "verified";
                        readonly reason?: string | undefined;
                    }[];
                    readonly reason?: string | undefined;
                    readonly mechanism?: "symlink" | "copied-directory" | "structured-entry" | "managed-region" | "generated-file" | undefined;
                    readonly proof?: string | undefined;
                }[];
                readonly locked?: boolean;
                readonly transport?: string;
                readonly duplicateDiscoveries?: readonly {
                    readonly agentId: string;
                    readonly nativeUnitKeys: readonly string[];
                }[];
                readonly sourceType?: string;
            }[];
            readonly count: number;
            readonly configuredCount: number;
            readonly implicitCount: number;
            readonly installedCount: number;
            readonly leftoverCount: number;
            readonly undeclaredCount: number;
            readonly unmanagedCount: number;
            readonly nativeLocationCounts?: {
                readonly units: number;
                readonly physicalLocations: number;
                readonly configuredConsumers: number;
                readonly unverifiedExtensions: number;
            };
        };
        rows: readonly Row[];
    }, E, R>;
    schema: Schema.Struct<{
        readonly items: Schema.$Array<Schema.Struct<{
            readonly agentOutcomes: Schema.$Array<Schema.Struct<{
                readonly extensionType: Schema.Literals<readonly ("skill" | "subagent" | "mcp-server" | "rule" | "hook" | "knowledge" | "pack")[]>;
                readonly name: Schema.String;
                readonly agentId: Schema.String;
                readonly outcome: Schema.Literals<readonly ["projected", "current", "not-applicable", "unsupported", "blocked", "failed"]>;
                readonly reasonCode: Schema.String;
                readonly reason: Schema.String;
                readonly mechanism: Schema.optional<Schema.String>;
                readonly path: Schema.optional<Schema.String>;
                readonly nativeUnitKeys: Schema.optional<Schema.$Array<Schema.String>>;
                readonly hook: Schema.optionalKey<Schema.Struct<{
                    readonly implementationId: Schema.String;
                    readonly protocol: Schema.String;
                    readonly bindings: Schema.$Array<Schema.Struct<{
                        readonly id: Schema.String;
                        readonly event: Schema.String;
                        readonly matcher: Schema.optionalKey<Schema.String>;
                        readonly runtime: Schema.String;
                        readonly entrypoint: Schema.String;
                        readonly requiredOutcomes: Schema.$Array<Schema.String>;
                        readonly requiredOperations: Schema.$Array<Schema.String>;
                    }>>;
                    readonly conditions: Schema.$Array<Schema.String>;
                    readonly configuration: Schema.Struct<{
                        readonly status: Schema.Literals<readonly ["valid", "invalid", "not-evaluated"]>;
                        readonly fields: Schema.$Array<Schema.Struct<{
                            readonly key: Schema.String;
                            readonly source: Schema.Literals<readonly ["consumer", "default", "unset"]>;
                            readonly value: Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
                            readonly redacted: Schema.Boolean;
                        }>>;
                        readonly issues: Schema.$Array<Schema.Struct<{
                            readonly key: Schema.String;
                            readonly message: Schema.String;
                        }>>;
                    }>;
                    readonly runtimeAvailability: Schema.Literal<"unverified">;
                    readonly nativeInvocation: Schema.Literal<"not-observed">;
                    readonly fixtureEvidence: Schema.Struct<{
                        readonly state: Schema.Literals<readonly ["absent", "invalid", "stale", "historical"]>;
                        readonly receipt: Schema.optionalKey<Schema.Struct<{
                            readonly kind: Schema.Literal<"fixture-execution">;
                            readonly package: Schema.String;
                            readonly version: Schema.String;
                            readonly contentHash: Schema.String;
                            readonly configurationHash: Schema.String;
                            readonly startedAt: Schema.Number;
                            readonly completedAt: Schema.Number;
                            readonly cwd: Schema.Literal<"package-root">;
                            readonly scope: Schema.Literals<readonly ["project", "user"]>;
                            readonly platform: Schema.Struct<{
                                readonly os: Schema.String;
                                readonly architecture: Schema.String;
                            }>;
                            readonly environment: Schema.$Array<Schema.String>;
                            readonly environmentFreshness: Schema.Literal<"historical-only">;
                            readonly nativeInvocation: Schema.Literal<"not-observed">;
                            readonly sandboxed: Schema.Literal<false>;
                            readonly fixtures: Schema.$Array<Schema.Struct<{
                                readonly fixture: Schema.String;
                                readonly implementation: Schema.String;
                                readonly binding: Schema.String;
                                readonly protocol: Schema.String;
                                readonly runtime: Schema.String;
                                readonly runtimeVersion: Schema.NullOr<Schema.String>;
                                readonly outcome: Schema.Literals<readonly ["passed", "failed"]>;
                                readonly expectedExitCode: Schema.Number;
                                readonly observedExitCode: Schema.NullOr<Schema.Number>;
                                readonly stdoutMatches: Schema.NullOr<Schema.Boolean>;
                                readonly stderrMatches: Schema.NullOr<Schema.Boolean>;
                                readonly detail: Schema.String;
                            }>>;
                            readonly passed: Schema.Boolean;
                            readonly receiptPath: Schema.String;
                        }>>;
                        readonly reason: Schema.String;
                    }>;
                }>>;
            }>>;
            readonly nativeLocations: Schema.optionalKey<Schema.$Array<Schema.Struct<{
                readonly scope: Schema.Literals<readonly ["project", "user"]>;
                readonly address: Schema.Union<readonly [Schema.Struct<{
                    readonly kind: Schema.Literal<"entry">;
                    readonly path: Schema.String;
                }>, Schema.Struct<{
                    readonly kind: Schema.Literal<"key-path">;
                    readonly path: Schema.String;
                    readonly keys: Schema.NonEmptyArray<Schema.String>;
                }>, Schema.Struct<{
                    readonly kind: Schema.Literal<"region">;
                    readonly path: Schema.String;
                    readonly region: Schema.String;
                }>, Schema.Struct<{
                    readonly kind: Schema.Literal<"file">;
                    readonly path: Schema.String;
                }>]>;
                readonly aliases: Schema.$Array<Schema.String>;
                readonly configuredConsumers: Schema.$Array<Schema.String>;
                readonly potentialReaders: Schema.$Array<Schema.String>;
                readonly policyReasons: Schema.$Array<Schema.String>;
                readonly ownership: Schema.Literals<readonly ["owned", "unowned", "absent", "unverified"]>;
                readonly proof: Schema.optional<Schema.String>;
                readonly state: Schema.Literals<readonly ["created", "updated", "removed", "retained", "unchanged", "blocked", "absent", "unverified"]>;
                readonly mechanism: Schema.optional<Schema.Literals<readonly ["symlink", "copied-directory", "structured-entry", "managed-region", "generated-file"]>>;
                readonly availability: Schema.$Array<Schema.Struct<{
                    readonly agentId: Schema.String;
                    readonly state: Schema.Literals<readonly ["verified", "unverified", "unavailable"]>;
                    readonly reason: Schema.optional<Schema.String>;
                }>>;
                readonly reason: Schema.optional<Schema.String>;
            }>>>;
            readonly duplicateDiscoveries: Schema.optionalKey<Schema.$Array<Schema.Struct<{
                readonly agentId: Schema.String;
                readonly nativeUnitKeys: Schema.$Array<Schema.String>;
            }>>>;
            readonly version: Schema.optionalKey<Schema.String>;
            readonly owner: Schema.optionalKey<Schema.String>;
            readonly transport: Schema.optionalKey<Schema.String>;
            readonly status: Schema.optionalKey<Schema.String>;
            readonly locked: Schema.optionalKey<Schema.Boolean>;
            readonly sourceType: Schema.optionalKey<Schema.String>;
            readonly scope: Schema.Literals<readonly ["project", "user"]>;
            readonly type: Schema.Literals<readonly ("skill" | "subagent" | "mcp-server" | "rule" | "hook" | "knowledge" | "pack")[]>;
            readonly name: Schema.String;
            readonly classification: Schema.Struct<{
                readonly kind: Schema.Literal<"lifecycle">;
                readonly lifecycle: Schema.Literals<readonly ["configured", "implicit", "leftover", "undeclared", "unmanaged"]>;
            }>;
            readonly enabled: Schema.NullOr<Schema.Boolean>;
            readonly installed: Schema.Boolean;
            readonly agents: Schema.$Array<Schema.String>;
            readonly origins: Schema.$Array<Schema.String>;
            readonly paths: Schema.$Array<Schema.String>;
            readonly source: Schema.optionalKey<Schema.String>;
        }>>;
        readonly count: Schema.Number;
        readonly configuredCount: Schema.Number;
        readonly implicitCount: Schema.Number;
        readonly installedCount: Schema.Number;
        readonly leftoverCount: Schema.Number;
        readonly undeclaredCount: Schema.Number;
        readonly unmanagedCount: Schema.Number;
        readonly nativeLocationCounts: Schema.optionalKey<Schema.Struct<{
            readonly units: Schema.Number;
            readonly physicalLocations: Schema.Number;
            readonly configuredConsumers: Schema.Number;
            readonly unverifiedExtensions: Schema.Number;
        }>>;
    }>;
    summary: (inventory: ExtensionInventory) => string;
};
export declare const makePerTypeListCommand: <Row, S extends Schema.Top, E extends ExpectedCliError, R>(definition: ListDefinition<Row, S, E, R>) => {
    handler: (args?: {
        readonly agents: ReadonlyArray<string>;
    } | undefined) => Effect.Effect<void, import("../../screen/streams.ts").OutputWriteFailed | E, import("../../screen/screen.ts").Screen | Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<R, import("@agentxm/registry-client").OperationRequestBudget>, import("@agentxm/registry-client").OperationExtractionBudget>, import("@agentxm/registry-client").OperationBufferedArchiveBudget>, import("@agentxm/registry-client").OperationScratchBudget>, import("@agentxm/registry-client").RegistryRetryObservation>, import("@agentxm/workspace-kernel/operations").OperationLifecycle>, never>, import("effect/Scope").Scope> | S["EncodingServices"]>;
    command: Command.Command<"list", {
        readonly scope: "user" | "project";
        readonly agent: readonly ("adal" | "fx" | "muse-code" | "mimo-code" | "coder-agents" | "aider-desk" | "amp" | "antigravity" | "antigravity-cli" | "augment" | "claude-code" | "cline" | "codearts-agent" | "codebuddy" | "codemaker" | "codestudio" | "codex" | "command-code" | "continue" | "cortex" | "crush" | "cursor" | "deepagents" | "devin" | "dexto" | "droid" | "firebender" | "forgecode" | "gemini-cli" | "github-copilot-cli" | "goose" | "grok-cli" | "hermes" | "ibm-bob" | "iflow-cli" | "junie" | "lingma" | "kilo" | "kimi-cli" | "kiro-cli" | "kode" | "mcpjam" | "minimax-code" | "mistral-vibe" | "mux" | "neovate" | "openclaw" | "opencode" | "openhands" | "ona" | "pi" | "vscode" | "pochi" | "qoder" | "qoder-cn" | "qwen-code" | "replit" | "roo" | "rovodev" | "tabnine-cli" | "trae-cn" | "trae" | "warp" | "windsurf" | "zencoder" | "zed" | "zenflow")[];
    }, {}, import("../../app-error/app-error.ts").AppError | import("../../screen/streams.ts").OutputWriteFailed, import("effect/FileSystem").FileSystem | import("effect/Path").Path | "effect/cli/GlobalFlag/axm-non-interactive" | "effect/cli/GlobalFlag/axm-json" | "effect/cli/GlobalFlag/axm-quiet" | "effect/cli/GlobalFlag/axm-verbose" | "effect/cli/GlobalFlag/axm-debug" | import("../../telemetry/client.ts").TelemetryClient | import("@agentxm/registry-access/authentication").DeviceLoginInteraction | "effect/cli/GlobalFlag/axm-directory">;
};
export {};
//# sourceMappingURL=list-command.d.ts.map