import { z } from "zod";
import { AihError } from "../errors.js";
import type { PlanContext } from "../internals/plan.js";
export declare const POLICY_HTTPS_ORIGIN_PATTERN = "^https://[A-Za-z0-9](?:[A-Za-z0-9.-]{0,251}[A-Za-z0-9])?(?::(?:[0-9]|[1-9][0-9]{1,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5]))?$";
export declare function normalizePolicyHost(value: string, source?: string): string;
export declare function normalizeHttpsOrigin(value: string, source?: string): string;
/**
 * AIH hard ceilings for the declarative Strix security policy. These are not
 * claimed as upstream Strix limits: this repository has no upstream owner
 * ceiling yet, so the conservative bounds keep a future headless scan bounded
 * until an execution consumer owns tighter per-mode budgets.
 */
export declare const STRIX_POLICY_LIMITS: Readonly<{
    readonly maxBudgetCents: 1000;
    readonly maxTurns: 20;
    readonly timeoutMs: 300000;
}>;
export declare const StrixSecurityPolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    targetKind: z.ZodLiteral<"local-fixture">;
    mode: z.ZodEnum<{
        deep: "deep";
        quick: "quick";
        standard: "standard";
    }>;
    maxBudgetCents: z.ZodNumber;
    maxTurns: z.ZodNumber;
    timeoutMs: z.ZodNumber;
    telemetry: z.ZodLiteral<"off">;
    imageDigest: z.ZodString;
    allowLiveTargets: z.ZodDefault<z.ZodLiteral<false>>;
    allowMounts: z.ZodDefault<z.ZodLiteral<false>>;
    enabled: z.ZodLiteral<true>;
    required: z.ZodBoolean;
}, z.core.$strict>, z.ZodObject<{
    targetKind: z.ZodLiteral<"local-fixture">;
    mode: z.ZodEnum<{
        deep: "deep";
        quick: "quick";
        standard: "standard";
    }>;
    maxBudgetCents: z.ZodNumber;
    maxTurns: z.ZodNumber;
    timeoutMs: z.ZodNumber;
    telemetry: z.ZodLiteral<"off">;
    imageDigest: z.ZodString;
    allowLiveTargets: z.ZodDefault<z.ZodLiteral<false>>;
    allowMounts: z.ZodDefault<z.ZodLiteral<false>>;
    enabled: z.ZodLiteral<false>;
    required: z.ZodLiteral<false>;
}, z.core.$strict>], "enabled">;
export declare const SupportedCliSchema: z.ZodEnum<{
    antigravity: "antigravity";
    claude: "claude";
    codex: "codex";
    copilot: "copilot";
    cursor: "cursor";
    gemini: "gemini";
    kimi: "kimi";
    kiro: "kiro";
    opencode: "opencode";
    windsurf: "windsurf";
    zed: "zed";
}>;
export declare function enterpriseSupportedClisJsonSchemaConstraint(): Record<string, unknown>;
/** Command arguments that are only safe when they carry an exact HTTPS origin. */
export declare const HTTPS_ORIGIN_ARGUMENT_PREFIXES: readonly ["--registry=", "--index-url="];
export declare function safePolicyCommandArgument(value: string): boolean;
export declare const CandidateSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
    type: z.ZodLiteral<"git">;
    repository: z.ZodString;
    commit: z.ZodString;
    tree: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"package">;
    registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
    package: z.ZodString;
    version: z.ZodString;
    integrity: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"command">;
    command: z.ZodString;
    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
    executableDigest: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"stdio">;
    resolver: z.ZodEnum<{
        npx: "npx";
        uvx: "uvx";
    }>;
    registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
    package: z.ZodString;
    version: z.ZodString;
    integrity: z.ZodString;
}, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
    type: z.ZodLiteral<"remote">;
    origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
    approval: z.ZodObject<{
        approvedBy: z.ZodString;
        authenticationMode: z.ZodString;
        allowedDataClasses: z.ZodArray<z.ZodString>;
    }, z.core.$strict>;
    contentScanned: z.ZodLiteral<false>;
    administrativeStatus: z.ZodEnum<{
        approved: "approved";
        revoked: "revoked";
    }>;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"remote">;
    origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
    approval: z.ZodObject<{
        approvedBy: z.ZodString;
        authenticationMode: z.ZodString;
        allowedDataClasses: z.ZodArray<z.ZodString>;
    }, z.core.$strict>;
    contentScanned: z.ZodLiteral<false>;
    toolSurfaceDigest: z.ZodString;
    verdict: z.ZodEnum<{
        approved: "approved";
        drifted: "drifted";
        revoked: "revoked";
    }>;
}, z.core.$strict>]>, z.ZodObject<{
    type: z.ZodLiteral<"mcp">;
    server: z.ZodString;
    subject: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"hook">;
    handler: z.ZodLiteral<"usage-metering">;
    scriptDigest: z.ZodString;
}, z.core.$strict>]>;
export declare const PolicyDangerCodeSchema: z.ZodEnum<{
    "auto-executing-hook": "auto-executing-hook";
    "dependency-confusion": "dependency-confusion";
    "evidence-identity-drift": "evidence-identity-drift";
    "hidden-unicode": "hidden-unicode";
    "malicious-code": "malicious-code";
    "mandatory-detector-failed": "mandatory-detector-failed";
    "missing-projector": "missing-projector";
    "normalized-collision": "normalized-collision";
    "ownership-conflict": "ownership-conflict";
    "prompt-injection": "prompt-injection";
    secrets: "secrets";
    "unpinned-source": "unpinned-source";
    "unsafe-path": "unsafe-path";
    "unsupported-target": "unsupported-target";
}>;
export declare const PolicyApprovalSchema: z.ZodObject<{
    id: z.ZodString;
    candidate: z.ZodString;
    kind: z.ZodEnum<{
        framework: "framework";
        hook: "hook";
        mcp: "mcp";
    }>;
    source: z.ZodUnion<readonly [z.ZodObject<{
        type: z.ZodLiteral<"git">;
        repository: z.ZodString;
        commit: z.ZodString;
        tree: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"package">;
        registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
        package: z.ZodString;
        version: z.ZodString;
        integrity: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"command">;
        command: z.ZodString;
        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
        executableDigest: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"stdio">;
        resolver: z.ZodEnum<{
            npx: "npx";
            uvx: "uvx";
        }>;
        registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
        package: z.ZodString;
        version: z.ZodString;
        integrity: z.ZodString;
    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
        type: z.ZodLiteral<"remote">;
        origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
        approval: z.ZodObject<{
            approvedBy: z.ZodString;
            authenticationMode: z.ZodString;
            allowedDataClasses: z.ZodArray<z.ZodString>;
        }, z.core.$strict>;
        contentScanned: z.ZodLiteral<false>;
        administrativeStatus: z.ZodEnum<{
            approved: "approved";
            revoked: "revoked";
        }>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"remote">;
        origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
        approval: z.ZodObject<{
            approvedBy: z.ZodString;
            authenticationMode: z.ZodString;
            allowedDataClasses: z.ZodArray<z.ZodString>;
        }, z.core.$strict>;
        contentScanned: z.ZodLiteral<false>;
        toolSurfaceDigest: z.ZodString;
        verdict: z.ZodEnum<{
            approved: "approved";
            drifted: "drifted";
            revoked: "revoked";
        }>;
    }, z.core.$strict>]>, z.ZodObject<{
        type: z.ZodLiteral<"mcp">;
        server: z.ZodString;
        subject: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"hook">;
        handler: z.ZodLiteral<"usage-metering">;
        scriptDigest: z.ZodString;
    }, z.core.$strict>]>;
    issuer: z.ZodString;
    sourceDigest: z.ZodString;
    evidenceDigest: z.ZodString;
    projector: z.ZodEnum<{
        "framework-contract": "framework-contract";
        "hook-managed-settings": "hook-managed-settings";
        "mcp-managed-settings": "mcp-managed-settings";
        "usage-hook": "usage-hook";
    }>;
    policyVersion: z.ZodString;
    reason: z.ZodString;
    clarification: z.ZodOptional<z.ZodString>;
    scope: z.ZodArray<z.ZodEnum<{
        claude: "claude";
        codex: "codex";
        kiro: "kiro";
    }>>;
    notBefore: z.ZodString;
    expiresAt: z.ZodString;
    github: z.ZodObject<{
        repository: z.ZodString;
        attestationId: z.ZodString;
        subjectDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>;
/** The one copy of native-field validation, shared by the grammar and the projector. */
export declare function nativeHookFieldIssues(fields: unknown, reserved?: readonly string[]): string[];
export declare const ThirdPartyLauncherPinSchema: z.ZodObject<{
    repository: z.ZodString;
    commit: z.ZodString;
    path: z.ZodString;
    launcherSha256: z.ZodString;
    runtimeVersion: z.ZodString;
}, z.core.$strict>;
declare const HookRegistrationOwnerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    kind: z.ZodLiteral<"aih">;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"third-party">;
    framework: z.ZodString;
    declaredControls: z.ZodDefault<z.ZodArray<z.ZodString>>;
    pin: z.ZodObject<{
        repository: z.ZodString;
        commit: z.ZodString;
        path: z.ZodString;
        launcherSha256: z.ZodString;
        runtimeVersion: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"unknown">;
    launcherSha256: z.ZodString;
}, z.core.$strict>], "kind">;
/**
 * The `hook-managed-settings` projector's own registration shape, carried by
 * the policy grammar as `governance.hookRegistrations` (G1). It lives here so
 * the grammar and the projector validate through ONE copy; the projector module
 * imports it rather than restating it.
 */
export declare const HookRegistrationSchema: z.ZodObject<{
    id: z.ZodString;
    event: z.ZodString;
    command: z.ZodString;
    functionTags: z.ZodArray<z.ZodString>;
    spawns: z.ZodNumber;
    timeout: z.ZodOptional<z.ZodNumber>;
    sourceDisabled: z.ZodDefault<z.ZodBoolean>;
    nativeGroup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    nativeHook: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"aih">;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"third-party">;
        framework: z.ZodString;
        declaredControls: z.ZodDefault<z.ZodArray<z.ZodString>>;
        pin: z.ZodObject<{
            repository: z.ZodString;
            commit: z.ZodString;
            path: z.ZodString;
            launcherSha256: z.ZodString;
            runtimeVersion: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"unknown">;
        launcherSha256: z.ZodString;
    }, z.core.$strict>], "kind">;
}, z.core.$strict>;
export type ThirdPartyLauncherPin = z.infer<typeof ThirdPartyLauncherPinSchema>;
export type HookRegistrationOwner = z.infer<typeof HookRegistrationOwnerSchema>;
export interface HookRegistration extends z.input<typeof HookRegistrationSchema> {
}
export type ResolvedHookRegistration = z.infer<typeof HookRegistrationSchema>;
export declare function hookCommandDigest(command: string): string;
/**
 * The one copy of registration-set validation: the policy grammar refuses
 * through it at parse time and the projector refuses through it before
 * emitting. A launcher whose hash no longer matches its pin is drift — refused,
 * never projected, because projecting it would be a silent update of code AIH
 * cannot read.
 */
export declare function hookRegistrationSetIssues(registrations: readonly ResolvedHookRegistration[]): {
    index: number;
    message: string;
}[];
declare const GovernedPolicyGovernanceSchema: z.ZodObject<{
    policyVersion: z.ZodString;
    catalog: z.ZodObject<{
        reviewed: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodEnum<{
                framework: "framework";
                hook: "hook";
                mcp: "mcp";
            }>;
            description: z.ZodString;
            capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
            risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
            source: z.ZodUnion<readonly [z.ZodObject<{
                type: z.ZodLiteral<"git">;
                repository: z.ZodString;
                commit: z.ZodString;
                tree: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"package">;
                registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                package: z.ZodString;
                version: z.ZodString;
                integrity: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"command">;
                command: z.ZodString;
                args: z.ZodDefault<z.ZodArray<z.ZodString>>;
                executableDigest: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"stdio">;
                resolver: z.ZodEnum<{
                    npx: "npx";
                    uvx: "uvx";
                }>;
                registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                package: z.ZodString;
                version: z.ZodString;
                integrity: z.ZodString;
            }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
                type: z.ZodLiteral<"remote">;
                origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                approval: z.ZodObject<{
                    approvedBy: z.ZodString;
                    authenticationMode: z.ZodString;
                    allowedDataClasses: z.ZodArray<z.ZodString>;
                }, z.core.$strict>;
                contentScanned: z.ZodLiteral<false>;
                administrativeStatus: z.ZodEnum<{
                    approved: "approved";
                    revoked: "revoked";
                }>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"remote">;
                origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                approval: z.ZodObject<{
                    approvedBy: z.ZodString;
                    authenticationMode: z.ZodString;
                    allowedDataClasses: z.ZodArray<z.ZodString>;
                }, z.core.$strict>;
                contentScanned: z.ZodLiteral<false>;
                toolSurfaceDigest: z.ZodString;
                verdict: z.ZodEnum<{
                    approved: "approved";
                    drifted: "drifted";
                    revoked: "revoked";
                }>;
            }, z.core.$strict>]>, z.ZodObject<{
                type: z.ZodLiteral<"mcp">;
                server: z.ZodString;
                subject: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"hook">;
                handler: z.ZodLiteral<"usage-metering">;
                scriptDigest: z.ZodString;
            }, z.core.$strict>]>;
            targets: z.ZodArray<z.ZodEnum<{
                claude: "claude";
                codex: "codex";
                kiro: "kiro";
            }>>;
            projector: z.ZodEnum<{
                "framework-contract": "framework-contract";
                "hook-managed-settings": "hook-managed-settings";
                "mcp-managed-settings": "mcp-managed-settings";
                "usage-hook": "usage-hook";
            }>;
            lifecycle: z.ZodEnum<{
                deprecated: "deprecated";
                retired: "retired";
                supported: "supported";
            }>;
            evidence: z.ZodObject<{
                record: z.ZodString;
            }, z.core.$strict>;
            findings: z.ZodDefault<z.ZodArray<z.ZodEnum<{
                "auto-executing-hook": "auto-executing-hook";
                "dependency-confusion": "dependency-confusion";
                "evidence-identity-drift": "evidence-identity-drift";
                "hidden-unicode": "hidden-unicode";
                "malicious-code": "malicious-code";
                "mandatory-detector-failed": "mandatory-detector-failed";
                "missing-projector": "missing-projector";
                "normalized-collision": "normalized-collision";
                "ownership-conflict": "ownership-conflict";
                "prompt-injection": "prompt-injection";
                secrets: "secrets";
                "unpinned-source": "unpinned-source";
                "unsafe-path": "unsafe-path";
                "unsupported-target": "unsupported-target";
            }>>>;
            autoExecute: z.ZodDefault<z.ZodBoolean>;
            framework: z.ZodOptional<z.ZodEnum<{
                ecc: "ecc";
                superpowers: "superpowers";
            }>>;
            clarification: z.ZodOptional<z.ZodString>;
            annotation: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
        custom: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodEnum<{
                framework: "framework";
                hook: "hook";
                mcp: "mcp";
            }>;
            description: z.ZodString;
            capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
            risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
            source: z.ZodUnion<readonly [z.ZodObject<{
                type: z.ZodLiteral<"git">;
                repository: z.ZodString;
                commit: z.ZodString;
                tree: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"package">;
                registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                package: z.ZodString;
                version: z.ZodString;
                integrity: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"command">;
                command: z.ZodString;
                args: z.ZodDefault<z.ZodArray<z.ZodString>>;
                executableDigest: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"stdio">;
                resolver: z.ZodEnum<{
                    npx: "npx";
                    uvx: "uvx";
                }>;
                registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                package: z.ZodString;
                version: z.ZodString;
                integrity: z.ZodString;
            }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
                type: z.ZodLiteral<"remote">;
                origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                approval: z.ZodObject<{
                    approvedBy: z.ZodString;
                    authenticationMode: z.ZodString;
                    allowedDataClasses: z.ZodArray<z.ZodString>;
                }, z.core.$strict>;
                contentScanned: z.ZodLiteral<false>;
                administrativeStatus: z.ZodEnum<{
                    approved: "approved";
                    revoked: "revoked";
                }>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"remote">;
                origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                approval: z.ZodObject<{
                    approvedBy: z.ZodString;
                    authenticationMode: z.ZodString;
                    allowedDataClasses: z.ZodArray<z.ZodString>;
                }, z.core.$strict>;
                contentScanned: z.ZodLiteral<false>;
                toolSurfaceDigest: z.ZodString;
                verdict: z.ZodEnum<{
                    approved: "approved";
                    drifted: "drifted";
                    revoked: "revoked";
                }>;
            }, z.core.$strict>]>, z.ZodObject<{
                type: z.ZodLiteral<"mcp">;
                server: z.ZodString;
                subject: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"hook">;
                handler: z.ZodLiteral<"usage-metering">;
                scriptDigest: z.ZodString;
            }, z.core.$strict>]>;
            targets: z.ZodArray<z.ZodEnum<{
                claude: "claude";
                codex: "codex";
                kiro: "kiro";
            }>>;
            projector: z.ZodEnum<{
                "framework-contract": "framework-contract";
                "hook-managed-settings": "hook-managed-settings";
                "mcp-managed-settings": "mcp-managed-settings";
                "usage-hook": "usage-hook";
            }>;
            lifecycle: z.ZodEnum<{
                deprecated: "deprecated";
                retired: "retired";
                supported: "supported";
            }>;
            evidence: z.ZodObject<{
                record: z.ZodString;
            }, z.core.$strict>;
            findings: z.ZodDefault<z.ZodArray<z.ZodEnum<{
                "auto-executing-hook": "auto-executing-hook";
                "dependency-confusion": "dependency-confusion";
                "evidence-identity-drift": "evidence-identity-drift";
                "hidden-unicode": "hidden-unicode";
                "malicious-code": "malicious-code";
                "mandatory-detector-failed": "mandatory-detector-failed";
                "missing-projector": "missing-projector";
                "normalized-collision": "normalized-collision";
                "ownership-conflict": "ownership-conflict";
                "prompt-injection": "prompt-injection";
                secrets: "secrets";
                "unpinned-source": "unpinned-source";
                "unsafe-path": "unsafe-path";
                "unsupported-target": "unsupported-target";
            }>>>;
            autoExecute: z.ZodDefault<z.ZodBoolean>;
            framework: z.ZodOptional<z.ZodEnum<{
                ecc: "ecc";
                superpowers: "superpowers";
            }>>;
            clarification: z.ZodOptional<z.ZodString>;
            annotation: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
    }, z.core.$strict>;
    activations: z.ZodDefault<z.ZodArray<z.ZodObject<{
        candidate: z.ZodString;
        state: z.ZodEnum<{
            active: "active";
            disabled: "disabled";
        }>;
        targets: z.ZodArray<z.ZodEnum<{
            claude: "claude";
            codex: "codex";
            kiro: "kiro";
        }>>;
        clarification: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
    authority: z.ZodDefault<z.ZodObject<{
        approvals: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            candidate: z.ZodString;
            kind: z.ZodEnum<{
                framework: "framework";
                hook: "hook";
                mcp: "mcp";
            }>;
            source: z.ZodUnion<readonly [z.ZodObject<{
                type: z.ZodLiteral<"git">;
                repository: z.ZodString;
                commit: z.ZodString;
                tree: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"package">;
                registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                package: z.ZodString;
                version: z.ZodString;
                integrity: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"command">;
                command: z.ZodString;
                args: z.ZodDefault<z.ZodArray<z.ZodString>>;
                executableDigest: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"stdio">;
                resolver: z.ZodEnum<{
                    npx: "npx";
                    uvx: "uvx";
                }>;
                registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                package: z.ZodString;
                version: z.ZodString;
                integrity: z.ZodString;
            }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
                type: z.ZodLiteral<"remote">;
                origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                approval: z.ZodObject<{
                    approvedBy: z.ZodString;
                    authenticationMode: z.ZodString;
                    allowedDataClasses: z.ZodArray<z.ZodString>;
                }, z.core.$strict>;
                contentScanned: z.ZodLiteral<false>;
                administrativeStatus: z.ZodEnum<{
                    approved: "approved";
                    revoked: "revoked";
                }>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"remote">;
                origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                approval: z.ZodObject<{
                    approvedBy: z.ZodString;
                    authenticationMode: z.ZodString;
                    allowedDataClasses: z.ZodArray<z.ZodString>;
                }, z.core.$strict>;
                contentScanned: z.ZodLiteral<false>;
                toolSurfaceDigest: z.ZodString;
                verdict: z.ZodEnum<{
                    approved: "approved";
                    drifted: "drifted";
                    revoked: "revoked";
                }>;
            }, z.core.$strict>]>, z.ZodObject<{
                type: z.ZodLiteral<"mcp">;
                server: z.ZodString;
                subject: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"hook">;
                handler: z.ZodLiteral<"usage-metering">;
                scriptDigest: z.ZodString;
            }, z.core.$strict>]>;
            issuer: z.ZodString;
            sourceDigest: z.ZodString;
            evidenceDigest: z.ZodString;
            projector: z.ZodEnum<{
                "framework-contract": "framework-contract";
                "hook-managed-settings": "hook-managed-settings";
                "mcp-managed-settings": "mcp-managed-settings";
                "usage-hook": "usage-hook";
            }>;
            policyVersion: z.ZodString;
            reason: z.ZodString;
            clarification: z.ZodOptional<z.ZodString>;
            scope: z.ZodArray<z.ZodEnum<{
                claude: "claude";
                codex: "codex";
                kiro: "kiro";
            }>>;
            notBefore: z.ZodString;
            expiresAt: z.ZodString;
            github: z.ZodObject<{
                repository: z.ZodString;
                attestationId: z.ZodString;
                subjectDigest: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>;
    externalCuration: z.ZodDefault<z.ZodArray<z.ZodObject<{
        framework: z.ZodEnum<{
            ecc: "ecc";
            superpowers: "superpowers";
        }>;
        items: z.ZodDefault<z.ZodArray<z.ZodObject<{
            kind: z.ZodEnum<{
                agent: "agent";
                command: "command";
                skill: "skill";
            }>;
            id: z.ZodString;
            source: z.ZodObject<{
                repository: z.ZodString;
                commit: z.ZodString;
                path: z.ZodString;
            }, z.core.$strict>;
            audit: z.ZodObject<{
                record: z.ZodString;
                digest: z.ZodString;
            }, z.core.$strict>;
            clarification: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>>;
    externalSelections: z.ZodDefault<z.ZodArray<z.ZodObject<{
        framework: z.ZodEnum<{
            ecc: "ecc";
            superpowers: "superpowers";
        }>;
        items: z.ZodDefault<z.ZodArray<z.ZodObject<{
            kind: z.ZodEnum<{
                agent: "agent";
                baseline: "baseline";
                capability: "capability";
                framework: "framework";
                lang: "lang";
                mcp: "mcp";
                module: "module";
                runtime: "runtime";
                skill: "skill";
            }>;
            id: z.ZodString;
            source: z.ZodObject<{
                repository: z.ZodString;
                commit: z.ZodString;
                path: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>>;
    eccMcpApprovals: z.ZodDefault<z.ZodArray<z.ZodObject<{
        id: z.ZodEnum<{
            "browser-use": "browser-use";
            browserbase: "browserbase";
            clickhouse: "clickhouse";
            "cloudflare-docs": "cloudflare-docs";
            "cloudflare-observability": "cloudflare-observability";
            "cloudflare-workers-bindings": "cloudflare-workers-bindings";
            "cloudflare-workers-builds": "cloudflare-workers-builds";
            codescene: "codescene";
            confluence: "confluence";
            devfleet: "devfleet";
            "ecc-memory-vault": "ecc-memory-vault";
            evalview: "evalview";
            "exa-web-search": "exa-web-search";
            "fal-ai": "fal-ai";
            filesystem: "filesystem";
            firecrawl: "firecrawl";
            "ito-compute": "ito-compute";
            jira: "jira";
            laraplugins: "laraplugins";
            longhand: "longhand";
            magic: "magic";
            memory: "memory";
            memxus: "memxus";
            nexus: "nexus";
            "omega-memory": "omega-memory";
            "parallel-search": "parallel-search";
            railway: "railway";
            squish: "squish";
            supabase: "supabase";
            "token-optimizer": "token-optimizer";
            vercel: "vercel";
        }>;
        sourceContentSha256: z.ZodLiteral<"a4426254c55a5352db2672bc86a87f10b0029f5e4ae1b74817841e87d9ab1e57">;
        state: z.ZodEnum<{
            approved: "approved";
            revoked: "revoked";
        }>;
        approvedBy: z.ZodString;
        authenticationMode: z.ZodString;
        allowedDataClasses: z.ZodArray<z.ZodString>;
    }, z.core.$strict>>>;
    eccHookControls: z.ZodOptional<z.ZodPipe<z.ZodObject<{
        profile: z.ZodEnum<{
            minimal: "minimal";
            standard: "standard";
            strict: "strict";
        }>;
        disabledIds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
            [x: string]: string;
        }>>>;
    }, z.core.$strict>, z.ZodTransform<{
        profile: "minimal" | "standard" | "strict";
        disabledIds?: string[] | undefined;
    }, {
        profile: "minimal" | "standard" | "strict";
        disabledIds?: string[] | undefined;
    }>>>;
    supportedClis: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        antigravity: "antigravity";
        claude: "claude";
        codex: "codex";
        copilot: "copilot";
        cursor: "cursor";
        gemini: "gemini";
        kimi: "kimi";
        kiro: "kiro";
        opencode: "opencode";
        windsurf: "windsurf";
        zed: "zed";
    }>>>;
    hookRegistrations: z.ZodDefault<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        event: z.ZodString;
        command: z.ZodString;
        functionTags: z.ZodArray<z.ZodString>;
        spawns: z.ZodNumber;
        timeout: z.ZodOptional<z.ZodNumber>;
        sourceDisabled: z.ZodDefault<z.ZodBoolean>;
        nativeGroup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        nativeHook: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"aih">;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"third-party">;
            framework: z.ZodString;
            declaredControls: z.ZodDefault<z.ZodArray<z.ZodString>>;
            pin: z.ZodObject<{
                repository: z.ZodString;
                commit: z.ZodString;
                path: z.ZodString;
                launcherSha256: z.ZodString;
                runtimeVersion: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"unknown">;
            launcherSha256: z.ZodString;
        }, z.core.$strict>], "kind">;
    }, z.core.$strict>>>;
}, z.core.$strict>;
/** Stable flattened input leaves for mechanical consumer-completeness contracts. */
export declare function schemaLeafPaths(schema: unknown, path?: string): string[];
/** Exact authorable governance leaves used by the policy consumer-completeness gate. */
export declare function policyGovernanceLeafPaths(): string[];
/** Exact authorable Strix leaves used by the policy consumer-completeness gate. */
export declare function policySecurityLeafPaths(): string[];
export declare const OrgPolicySchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<2>;
    minimumPosture: z.ZodEnum<{
        enterprise: "enterprise";
        vibe: "vibe";
    }>;
    references: z.ZodObject<{
        repoContract: z.ZodString;
    }, z.core.$strip>;
    command: z.ZodOptional<z.ZodObject<{
        deny: z.ZodOptional<z.ZodObject<{
            add: z.ZodDefault<z.ZodArray<z.ZodObject<{
                pattern: z.ZodString;
                reason: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
            remove: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
        ask: z.ZodOptional<z.ZodObject<{
            add: z.ZodDefault<z.ZodArray<z.ZodObject<{
                pattern: z.ZodString;
                reason: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
            remove: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    riskGates: z.ZodOptional<z.ZodObject<{
        add: z.ZodDefault<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            description: z.ZodString;
            pathPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
            commandPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
        override: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            pathPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
            commandPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>;
    licenses: z.ZodOptional<z.ZodObject<{
        disposition: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
            alert: "alert";
            "auto-approve": "auto-approve";
            block: "block";
            fail: "fail";
        }>>>;
    }, z.core.$strict>>;
    security: z.ZodOptional<z.ZodObject<{
        strix: z.ZodDiscriminatedUnion<[z.ZodObject<{
            targetKind: z.ZodLiteral<"local-fixture">;
            mode: z.ZodEnum<{
                deep: "deep";
                quick: "quick";
                standard: "standard";
            }>;
            maxBudgetCents: z.ZodNumber;
            maxTurns: z.ZodNumber;
            timeoutMs: z.ZodNumber;
            telemetry: z.ZodLiteral<"off">;
            imageDigest: z.ZodString;
            allowLiveTargets: z.ZodDefault<z.ZodLiteral<false>>;
            allowMounts: z.ZodDefault<z.ZodLiteral<false>>;
            enabled: z.ZodLiteral<true>;
            required: z.ZodBoolean;
        }, z.core.$strict>, z.ZodObject<{
            targetKind: z.ZodLiteral<"local-fixture">;
            mode: z.ZodEnum<{
                deep: "deep";
                quick: "quick";
                standard: "standard";
            }>;
            maxBudgetCents: z.ZodNumber;
            maxTurns: z.ZodNumber;
            timeoutMs: z.ZodNumber;
            telemetry: z.ZodLiteral<"off">;
            imageDigest: z.ZodString;
            allowLiveTargets: z.ZodDefault<z.ZodLiteral<false>>;
            allowMounts: z.ZodDefault<z.ZodLiteral<false>>;
            enabled: z.ZodLiteral<false>;
            required: z.ZodLiteral<false>;
        }, z.core.$strict>], "enabled">;
    }, z.core.$strict>>;
    mcp: z.ZodOptional<z.ZodObject<{
        allowedServers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        approvals: z.ZodDefault<z.ZodArray<z.ZodObject<{
            server: z.ZodString;
            subject: z.ZodOptional<z.ZodString>;
            acceptEgress: z.ZodLiteral<true>;
            reason: z.ZodString;
            reviewer: z.ZodOptional<z.ZodString>;
            approvedAt: z.ZodString;
        }, z.core.$strict>>>;
        allowManagedOnly: z.ZodDefault<z.ZodBoolean>;
        incumbentHosts: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
        githubHost: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
        disabledServers: z.ZodDefault<z.ZodArray<z.ZodString>>;
    }, z.core.$strict>>;
    trust: z.ZodOptional<z.ZodObject<{
        approvedSources: z.ZodOptional<z.ZodArray<z.ZodObject<{
            owner: z.ZodString;
            repo: z.ZodString;
            pinnedSha: z.ZodOptional<z.ZodString>;
            reason: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
        requireSignedSource: z.ZodDefault<z.ZodBoolean>;
        requiredDetectors: z.ZodOptional<z.ZodArray<z.ZodEnum<{
            cisco: "cisco";
            "mcp-scanner": "mcp-scanner";
            semgrep: "semgrep";
            skillspector: "skillspector";
            "snyk-agent-scan": "snyk-agent-scan";
        }>>>;
        requiredChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
        baselineOverrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
            catalog: z.ZodEnum<{
                ecc: "ecc";
                superpowers: "superpowers";
            }>;
            owner: z.ZodString;
            repo: z.ZodString;
            pinnedSha: z.ZodString;
            bundle: z.ZodString;
            signingRepository: z.ZodString;
            reason: z.ZodString;
            reviewer: z.ZodString;
            approvedAt: z.ZodString;
        }, z.core.$strict>>>;
        internalScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        skillspector: z.ZodOptional<z.ZodObject<{
            approvedDigests: z.ZodDefault<z.ZodArray<z.ZodObject<{
                imageTag: z.ZodString;
                imageDigest: z.ZodString;
                sourceRevision: z.ZodString;
                reason: z.ZodString;
                reviewer: z.ZodOptional<z.ZodString>;
                approvedAt: z.ZodString;
            }, z.core.$strict>>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    capabilityPackages: z.ZodOptional<z.ZodObject<{
        catalog: z.ZodObject<{
            provider: z.ZodLiteral<"github">;
            repository: z.ZodString;
        }, z.core.$strict>;
        roots: z.ZodArray<z.ZodString>;
    }, z.core.$strict>>;
    governance: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
        supportedClis: z.ZodArray<z.ZodEnum<{
            antigravity: "antigravity";
            claude: "claude";
            codex: "codex";
            copilot: "copilot";
            cursor: "cursor";
            gemini: "gemini";
            kimi: "kimi";
            kiro: "kiro";
            opencode: "opencode";
            windsurf: "windsurf";
            zed: "zed";
        }>>;
    }, z.core.$strict>, z.ZodObject<{
        policyVersion: z.ZodString;
        catalog: z.ZodObject<{
            reviewed: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                kind: z.ZodEnum<{
                    framework: "framework";
                    hook: "hook";
                    mcp: "mcp";
                }>;
                description: z.ZodString;
                capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
                risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
                source: z.ZodUnion<readonly [z.ZodObject<{
                    type: z.ZodLiteral<"git">;
                    repository: z.ZodString;
                    commit: z.ZodString;
                    tree: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"package">;
                    registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    package: z.ZodString;
                    version: z.ZodString;
                    integrity: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"command">;
                    command: z.ZodString;
                    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
                    executableDigest: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"stdio">;
                    resolver: z.ZodEnum<{
                        npx: "npx";
                        uvx: "uvx";
                    }>;
                    registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    package: z.ZodString;
                    version: z.ZodString;
                    integrity: z.ZodString;
                }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
                    type: z.ZodLiteral<"remote">;
                    origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    approval: z.ZodObject<{
                        approvedBy: z.ZodString;
                        authenticationMode: z.ZodString;
                        allowedDataClasses: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    contentScanned: z.ZodLiteral<false>;
                    administrativeStatus: z.ZodEnum<{
                        approved: "approved";
                        revoked: "revoked";
                    }>;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"remote">;
                    origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    approval: z.ZodObject<{
                        approvedBy: z.ZodString;
                        authenticationMode: z.ZodString;
                        allowedDataClasses: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    contentScanned: z.ZodLiteral<false>;
                    toolSurfaceDigest: z.ZodString;
                    verdict: z.ZodEnum<{
                        approved: "approved";
                        drifted: "drifted";
                        revoked: "revoked";
                    }>;
                }, z.core.$strict>]>, z.ZodObject<{
                    type: z.ZodLiteral<"mcp">;
                    server: z.ZodString;
                    subject: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"hook">;
                    handler: z.ZodLiteral<"usage-metering">;
                    scriptDigest: z.ZodString;
                }, z.core.$strict>]>;
                targets: z.ZodArray<z.ZodEnum<{
                    claude: "claude";
                    codex: "codex";
                    kiro: "kiro";
                }>>;
                projector: z.ZodEnum<{
                    "framework-contract": "framework-contract";
                    "hook-managed-settings": "hook-managed-settings";
                    "mcp-managed-settings": "mcp-managed-settings";
                    "usage-hook": "usage-hook";
                }>;
                lifecycle: z.ZodEnum<{
                    deprecated: "deprecated";
                    retired: "retired";
                    supported: "supported";
                }>;
                evidence: z.ZodObject<{
                    record: z.ZodString;
                }, z.core.$strict>;
                findings: z.ZodDefault<z.ZodArray<z.ZodEnum<{
                    "auto-executing-hook": "auto-executing-hook";
                    "dependency-confusion": "dependency-confusion";
                    "evidence-identity-drift": "evidence-identity-drift";
                    "hidden-unicode": "hidden-unicode";
                    "malicious-code": "malicious-code";
                    "mandatory-detector-failed": "mandatory-detector-failed";
                    "missing-projector": "missing-projector";
                    "normalized-collision": "normalized-collision";
                    "ownership-conflict": "ownership-conflict";
                    "prompt-injection": "prompt-injection";
                    secrets: "secrets";
                    "unpinned-source": "unpinned-source";
                    "unsafe-path": "unsafe-path";
                    "unsupported-target": "unsupported-target";
                }>>>;
                autoExecute: z.ZodDefault<z.ZodBoolean>;
                framework: z.ZodOptional<z.ZodEnum<{
                    ecc: "ecc";
                    superpowers: "superpowers";
                }>>;
                clarification: z.ZodOptional<z.ZodString>;
                annotation: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
            custom: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                kind: z.ZodEnum<{
                    framework: "framework";
                    hook: "hook";
                    mcp: "mcp";
                }>;
                description: z.ZodString;
                capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
                risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
                source: z.ZodUnion<readonly [z.ZodObject<{
                    type: z.ZodLiteral<"git">;
                    repository: z.ZodString;
                    commit: z.ZodString;
                    tree: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"package">;
                    registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    package: z.ZodString;
                    version: z.ZodString;
                    integrity: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"command">;
                    command: z.ZodString;
                    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
                    executableDigest: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"stdio">;
                    resolver: z.ZodEnum<{
                        npx: "npx";
                        uvx: "uvx";
                    }>;
                    registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    package: z.ZodString;
                    version: z.ZodString;
                    integrity: z.ZodString;
                }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
                    type: z.ZodLiteral<"remote">;
                    origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    approval: z.ZodObject<{
                        approvedBy: z.ZodString;
                        authenticationMode: z.ZodString;
                        allowedDataClasses: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    contentScanned: z.ZodLiteral<false>;
                    administrativeStatus: z.ZodEnum<{
                        approved: "approved";
                        revoked: "revoked";
                    }>;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"remote">;
                    origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    approval: z.ZodObject<{
                        approvedBy: z.ZodString;
                        authenticationMode: z.ZodString;
                        allowedDataClasses: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    contentScanned: z.ZodLiteral<false>;
                    toolSurfaceDigest: z.ZodString;
                    verdict: z.ZodEnum<{
                        approved: "approved";
                        drifted: "drifted";
                        revoked: "revoked";
                    }>;
                }, z.core.$strict>]>, z.ZodObject<{
                    type: z.ZodLiteral<"mcp">;
                    server: z.ZodString;
                    subject: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"hook">;
                    handler: z.ZodLiteral<"usage-metering">;
                    scriptDigest: z.ZodString;
                }, z.core.$strict>]>;
                targets: z.ZodArray<z.ZodEnum<{
                    claude: "claude";
                    codex: "codex";
                    kiro: "kiro";
                }>>;
                projector: z.ZodEnum<{
                    "framework-contract": "framework-contract";
                    "hook-managed-settings": "hook-managed-settings";
                    "mcp-managed-settings": "mcp-managed-settings";
                    "usage-hook": "usage-hook";
                }>;
                lifecycle: z.ZodEnum<{
                    deprecated: "deprecated";
                    retired: "retired";
                    supported: "supported";
                }>;
                evidence: z.ZodObject<{
                    record: z.ZodString;
                }, z.core.$strict>;
                findings: z.ZodDefault<z.ZodArray<z.ZodEnum<{
                    "auto-executing-hook": "auto-executing-hook";
                    "dependency-confusion": "dependency-confusion";
                    "evidence-identity-drift": "evidence-identity-drift";
                    "hidden-unicode": "hidden-unicode";
                    "malicious-code": "malicious-code";
                    "mandatory-detector-failed": "mandatory-detector-failed";
                    "missing-projector": "missing-projector";
                    "normalized-collision": "normalized-collision";
                    "ownership-conflict": "ownership-conflict";
                    "prompt-injection": "prompt-injection";
                    secrets: "secrets";
                    "unpinned-source": "unpinned-source";
                    "unsafe-path": "unsafe-path";
                    "unsupported-target": "unsupported-target";
                }>>>;
                autoExecute: z.ZodDefault<z.ZodBoolean>;
                framework: z.ZodOptional<z.ZodEnum<{
                    ecc: "ecc";
                    superpowers: "superpowers";
                }>>;
                clarification: z.ZodOptional<z.ZodString>;
                annotation: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
        }, z.core.$strict>;
        activations: z.ZodDefault<z.ZodArray<z.ZodObject<{
            candidate: z.ZodString;
            state: z.ZodEnum<{
                active: "active";
                disabled: "disabled";
            }>;
            targets: z.ZodArray<z.ZodEnum<{
                claude: "claude";
                codex: "codex";
                kiro: "kiro";
            }>>;
            clarification: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
        authority: z.ZodDefault<z.ZodObject<{
            approvals: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                candidate: z.ZodString;
                kind: z.ZodEnum<{
                    framework: "framework";
                    hook: "hook";
                    mcp: "mcp";
                }>;
                source: z.ZodUnion<readonly [z.ZodObject<{
                    type: z.ZodLiteral<"git">;
                    repository: z.ZodString;
                    commit: z.ZodString;
                    tree: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"package">;
                    registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    package: z.ZodString;
                    version: z.ZodString;
                    integrity: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"command">;
                    command: z.ZodString;
                    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
                    executableDigest: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"stdio">;
                    resolver: z.ZodEnum<{
                        npx: "npx";
                        uvx: "uvx";
                    }>;
                    registry: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    package: z.ZodString;
                    version: z.ZodString;
                    integrity: z.ZodString;
                }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
                    type: z.ZodLiteral<"remote">;
                    origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    approval: z.ZodObject<{
                        approvedBy: z.ZodString;
                        authenticationMode: z.ZodString;
                        allowedDataClasses: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    contentScanned: z.ZodLiteral<false>;
                    administrativeStatus: z.ZodEnum<{
                        approved: "approved";
                        revoked: "revoked";
                    }>;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"remote">;
                    origin: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                    approval: z.ZodObject<{
                        approvedBy: z.ZodString;
                        authenticationMode: z.ZodString;
                        allowedDataClasses: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    contentScanned: z.ZodLiteral<false>;
                    toolSurfaceDigest: z.ZodString;
                    verdict: z.ZodEnum<{
                        approved: "approved";
                        drifted: "drifted";
                        revoked: "revoked";
                    }>;
                }, z.core.$strict>]>, z.ZodObject<{
                    type: z.ZodLiteral<"mcp">;
                    server: z.ZodString;
                    subject: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    type: z.ZodLiteral<"hook">;
                    handler: z.ZodLiteral<"usage-metering">;
                    scriptDigest: z.ZodString;
                }, z.core.$strict>]>;
                issuer: z.ZodString;
                sourceDigest: z.ZodString;
                evidenceDigest: z.ZodString;
                projector: z.ZodEnum<{
                    "framework-contract": "framework-contract";
                    "hook-managed-settings": "hook-managed-settings";
                    "mcp-managed-settings": "mcp-managed-settings";
                    "usage-hook": "usage-hook";
                }>;
                policyVersion: z.ZodString;
                reason: z.ZodString;
                clarification: z.ZodOptional<z.ZodString>;
                scope: z.ZodArray<z.ZodEnum<{
                    claude: "claude";
                    codex: "codex";
                    kiro: "kiro";
                }>>;
                notBefore: z.ZodString;
                expiresAt: z.ZodString;
                github: z.ZodObject<{
                    repository: z.ZodString;
                    attestationId: z.ZodString;
                    subjectDigest: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>>>;
        }, z.core.$strict>>;
        externalCuration: z.ZodDefault<z.ZodArray<z.ZodObject<{
            framework: z.ZodEnum<{
                ecc: "ecc";
                superpowers: "superpowers";
            }>;
            items: z.ZodDefault<z.ZodArray<z.ZodObject<{
                kind: z.ZodEnum<{
                    agent: "agent";
                    command: "command";
                    skill: "skill";
                }>;
                id: z.ZodString;
                source: z.ZodObject<{
                    repository: z.ZodString;
                    commit: z.ZodString;
                    path: z.ZodString;
                }, z.core.$strict>;
                audit: z.ZodObject<{
                    record: z.ZodString;
                    digest: z.ZodString;
                }, z.core.$strict>;
                clarification: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
        }, z.core.$strict>>>;
        externalSelections: z.ZodDefault<z.ZodArray<z.ZodObject<{
            framework: z.ZodEnum<{
                ecc: "ecc";
                superpowers: "superpowers";
            }>;
            items: z.ZodDefault<z.ZodArray<z.ZodObject<{
                kind: z.ZodEnum<{
                    agent: "agent";
                    baseline: "baseline";
                    capability: "capability";
                    framework: "framework";
                    lang: "lang";
                    mcp: "mcp";
                    module: "module";
                    runtime: "runtime";
                    skill: "skill";
                }>;
                id: z.ZodString;
                source: z.ZodObject<{
                    repository: z.ZodString;
                    commit: z.ZodString;
                    path: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>>>;
        }, z.core.$strict>>>;
        eccMcpApprovals: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodEnum<{
                "browser-use": "browser-use";
                browserbase: "browserbase";
                clickhouse: "clickhouse";
                "cloudflare-docs": "cloudflare-docs";
                "cloudflare-observability": "cloudflare-observability";
                "cloudflare-workers-bindings": "cloudflare-workers-bindings";
                "cloudflare-workers-builds": "cloudflare-workers-builds";
                codescene: "codescene";
                confluence: "confluence";
                devfleet: "devfleet";
                "ecc-memory-vault": "ecc-memory-vault";
                evalview: "evalview";
                "exa-web-search": "exa-web-search";
                "fal-ai": "fal-ai";
                filesystem: "filesystem";
                firecrawl: "firecrawl";
                "ito-compute": "ito-compute";
                jira: "jira";
                laraplugins: "laraplugins";
                longhand: "longhand";
                magic: "magic";
                memory: "memory";
                memxus: "memxus";
                nexus: "nexus";
                "omega-memory": "omega-memory";
                "parallel-search": "parallel-search";
                railway: "railway";
                squish: "squish";
                supabase: "supabase";
                "token-optimizer": "token-optimizer";
                vercel: "vercel";
            }>;
            sourceContentSha256: z.ZodLiteral<"a4426254c55a5352db2672bc86a87f10b0029f5e4ae1b74817841e87d9ab1e57">;
            state: z.ZodEnum<{
                approved: "approved";
                revoked: "revoked";
            }>;
            approvedBy: z.ZodString;
            authenticationMode: z.ZodString;
            allowedDataClasses: z.ZodArray<z.ZodString>;
        }, z.core.$strict>>>;
        eccHookControls: z.ZodOptional<z.ZodPipe<z.ZodObject<{
            profile: z.ZodEnum<{
                minimal: "minimal";
                standard: "standard";
                strict: "strict";
            }>;
            disabledIds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                [x: string]: string;
            }>>>;
        }, z.core.$strict>, z.ZodTransform<{
            profile: "minimal" | "standard" | "strict";
            disabledIds?: string[] | undefined;
        }, {
            profile: "minimal" | "standard" | "strict";
            disabledIds?: string[] | undefined;
        }>>>;
        supportedClis: z.ZodOptional<z.ZodArray<z.ZodEnum<{
            antigravity: "antigravity";
            claude: "claude";
            codex: "codex";
            copilot: "copilot";
            cursor: "cursor";
            gemini: "gemini";
            kimi: "kimi";
            kiro: "kiro";
            opencode: "opencode";
            windsurf: "windsurf";
            zed: "zed";
        }>>>;
        hookRegistrations: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            event: z.ZodString;
            command: z.ZodString;
            functionTags: z.ZodArray<z.ZodString>;
            spawns: z.ZodNumber;
            timeout: z.ZodOptional<z.ZodNumber>;
            sourceDisabled: z.ZodDefault<z.ZodBoolean>;
            nativeGroup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            nativeHook: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"aih">;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"third-party">;
                framework: z.ZodString;
                declaredControls: z.ZodDefault<z.ZodArray<z.ZodString>>;
                pin: z.ZodObject<{
                    repository: z.ZodString;
                    commit: z.ZodString;
                    path: z.ZodString;
                    launcherSha256: z.ZodString;
                    runtimeVersion: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"unknown">;
                launcherSha256: z.ZodString;
            }, z.core.$strict>], "kind">;
        }, z.core.$strict>>>;
    }, z.core.$strict>]>>;
}, z.core.$strict>;
type ParsedOrgPolicy = z.infer<typeof OrgPolicySchema>;
export type OrgPolicy = Omit<ParsedOrgPolicy, "governance"> & {
    governance?: z.infer<typeof GovernedPolicyGovernanceSchema>;
};
type GovernedOrgPolicy = OrgPolicy & {
    governance: NonNullable<OrgPolicy["governance"]>;
};
/**
 * A supported-CLI allow-list is a sanction gate, not a request to take over
 * MCP or hook projection. Only a policy carrying governed inventory, decisions,
 * authority, curation, or registrar records owns those AIH surfaces.
 */
export declare function governanceOwnsAihSurfaces(policy: OrgPolicy | undefined): policy is GovernedOrgPolicy;
export declare class OrgPolicyError extends AihError {
    constructor(message: string);
}
export declare function parseOrgPolicy(value: unknown): OrgPolicy;
/**
 * A governed inventory is the sole authority for AIH-owned MCP and hook
 * mutations. Generic commands must not union legacy selections into it.
 */
export declare function assertGovernanceOwnsSurface(ctx: PlanContext, surface: "mcp" | "usage"): void;
export declare function orgPolicyPath(root: string, env: NodeJS.ProcessEnv): string;
/** Did the operator explicitly name a policy file, rather than relying on the repo default? */
export declare function hasExplicitOrgPolicySource(env: NodeJS.ProcessEnv): boolean;
export declare function readOrgPolicy(root: string, env: NodeJS.ProcessEnv): OrgPolicy | undefined;
export {};