/**
 * Policy gate module for the Kubun engine.
 *
 * Policies gate engine operations with sync-before-async ordering.
 * Each gate has optional sync and async check arrays. Sync checks run first
 * (fast, in-memory). If any sync check fails, async checks are skipped entirely.
 *
 * Result types follow the Standard Schema output specification:
 * - Success: `{ value }` — the context passes through
 * - Failure: `{ issues }` — an array of issues with at minimum a `message` field
 */
/**
 * A path segment in a policy issue, matching StandardSchemaV1.PathSegment.
 */
export type PolicyPathSegment = {
    readonly key: PropertyKey;
};
/**
 * A policy issue, matching StandardSchemaV1.Issue.
 */
export type PolicyIssue = {
    readonly message: string;
    readonly path?: ReadonlyArray<PropertyKey | PolicyPathSegment> | undefined;
};
/**
 * Successful policy check result.
 */
export type PolicySuccessResult<TContext = unknown> = {
    readonly value: TContext;
    readonly issues?: undefined;
};
/**
 * Failed policy check result.
 */
export type PolicyFailureResult = {
    readonly issues: ReadonlyArray<PolicyIssue>;
};
/**
 * The result of a policy check — either success or failure.
 */
export type PolicyResult<TContext = unknown> = PolicySuccessResult<TContext> | PolicyFailureResult;
/**
 * A synchronous policy check function.
 * Returns a Standard Schema result immediately (in-memory, fast).
 */
export type SyncPolicyCheck<TContext = unknown> = (context: TContext) => PolicyResult<TContext>;
/**
 * An asynchronous policy check function.
 * Returns a Promise of a Standard Schema result (may involve DB lookups, etc.).
 */
export type AsyncPolicyCheck<TContext = unknown> = (context: TContext) => Promise<PolicyResult<TContext>>;
/**
 * A single policy gate with optional sync and async check arrays.
 */
export type PolicyGate<TContext = unknown> = {
    sync?: Array<SyncPolicyCheck<TContext>>;
    async?: Array<AsyncPolicyCheck<TContext>>;
};
/**
 * Map of gate type names to their policy gates.
 */
export type PolicyGateMap<TContext = unknown> = Record<string, PolicyGate<TContext>>;
/**
 * Run all policy checks for a given gate type.
 *
 * Execution order:
 * 1. Run ALL sync checks — fail fast if any return issues
 * 2. Run ALL async checks — fail fast if any return issues
 * 3. Return success with the original context
 *
 * If the gate type is not present in the map, the operation is allowed by default.
 */
export declare function runPolicies<TContext>(gates: PolicyGateMap<TContext>, gateType: string, context: TContext): Promise<PolicyResult<TContext>>;