/**
 * SlackPermissionObserver — the single object the SlackAdapter calls to evaluate a
 * message against the permission gate. Composes resolver → gate → ledger.
 *
 * Slice 0 ships OBSERVE-ONLY: `observe()` evaluates and RECORDS the verdict but
 * never blocks the message path (enforce=false). This lets us measure the gate's
 * decisions (and false-positive rate) against real traffic before enforcement is
 * ever switched on (§11). It must NEVER throw — a failure here cannot break delivery.
 *
 * Design: docs/specs/SLACK-ORG-INTEGRATION-SPEC.md §6.6, §6.10, §11.
 *
 * RULE 3: EXEMPT — the "Observer" here is a permission-gate orchestrator
 * (resolver → gate → ledger + baseline feed), NOT a provider/external-state
 * detector. It parses no process output, tails no logs, and reads no
 * tmux/CLI state — so the state-detection-robustness rule (provider portability)
 * does not apply. Its only inputs are an already-parsed Slack message envelope
 * and the deterministic permission gate.
 */
import type { PermissionVerdict } from './types.js';
import type { SlackPrincipalResolver } from './SlackPrincipalResolver.js';
import type { SlackPermissionGate } from './SlackPermissionGate.js';
import type { PermissionDecisionLedger } from './PermissionDecisionLedger.js';
import type { RelationshipBehaviorStore } from './RelationshipBehaviorStore.js';
export interface ObserveInput {
    slackUserId: string;
    displayName?: string;
    text: string;
    directed: boolean;
    channel?: string;
}
export interface SlackPermissionObserverDeps {
    resolver: SlackPrincipalResolver;
    gate: SlackPermissionGate;
    ledger: PermissionDecisionLedger;
    /** When true the observer would ENFORCE (block). Slice 0 ships observe-only (false). */
    enforce?: boolean;
    /**
     * Optional behavioral baseline store (Pillar 3). When present, every observed
     * request's SHAPE (action/tier/hour/length/urgency — never content) is recorded
     * so the RelationshipAnomalyScorer's baseline grows from real traffic. Off by
     * default (Pillar 3 ships dark). Recording is best-effort and never blocks.
     */
    behaviorStore?: RelationshipBehaviorStore;
    /** Now() for the recorded hour-of-day (injectable for tests). */
    now?: () => Date;
}
export declare class SlackPermissionObserver {
    private readonly deps;
    constructor(deps: SlackPermissionObserverDeps);
    /** Resolve → evaluate → record (observe-only). Returns the verdict; never throws. */
    observe(input: ObserveInput): Promise<PermissionVerdict | null>;
    /**
     * Feed the behavioral baseline (Pillar 3) with the request's SHAPE — never content.
     * Best-effort: a failure here cannot break the message path. Only records DIRECTED
     * requests from a verified slackUserId (overheard chatter is not "this person's
     * normal behavior"), so the baseline reflects real interactions, not channel noise.
     */
    private recordBehavior;
    get enforcing(): boolean;
}
//# sourceMappingURL=SlackPermissionObserver.d.ts.map