import { A as StateMachine, c as AnyEventObject, p as EventObject, v as MetaObject, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
import "./StateMachine-EDpYWy0i.js";
import { t as Manager } from "./Manager-CQQ99QOI.js";
//#region src/modules/trust-graph/trustGraphManager.d.ts
type TrustGraphIdleState = {
  status: 'idle';
};
type TrustGraphFinishedState = {
  status: 'finished';
};
/**
 * Union of all possible trust-graph manager states.
 *
 * @example
 * ```typescript
 * const state = trustGraphManager.getState();
 * if (state.status === 'finished') {
 *   console.log('Trust graph check complete');
 * }
 * ```
 */
type TrustGraphState = TrustGraphIdleState | TrustGraphFinishedState;
/**
 * Creates a trust-graph manager for headless usage.
 *
 * @example Headless usage
 * ```typescript
 * const manager = createTrustGraphManager();
 * manager.subscribe((state) => console.log(state.status));
 * manager.load();
 * ```
 */
declare function createTrustGraphManager(): Manager<TrustGraphState> & {
  /**
   * Retained for API compatibility. Trust-graph is a headless skip module
   * whose machine starts in `finished` (backend-only, no SDK action), so there
   * is nothing to kick off and calling this has no effect.
   *
   * @deprecated The module completes on its own as soon as the manager is
   * created; reading `getState()` / subscribing is sufficient.
   */
  load(): void;
};
type TrustGraphManager = ReturnType<typeof createTrustGraphManager>;
//#endregion
//#region src/modules/trust-graph/trustGraphStateMachine.d.ts
type TrustGraphContext = Record<string, never>;
/**
 * Trust-graph is a headless "skip" module: it has no UI and the SDK performs no
 * client-side action. The backend runs the analysis from session data already
 * collected, so the machine must reach its `final` state as soon as it starts.
 *
 * The flow orchestrator invokes this machine via `runChildModule` and advances
 * the flow only when the invoked machine *completes* (reaches a top-level
 * `final` state) — it never sends a kickoff event. A machine that waited for an
 * external event (e.g. `LOAD`) would therefore never complete inside a flow,
 * leaving an empty shell on screen and the session permanently incomplete.
 *
 * Mirror the `noOpFlowModuleMachine` / `identitySearchMachine` headless pattern:
 * start directly in the `final` state.
 */
declare const trustGraphMachine: StateMachine<TrustGraphContext, AnyEventObject, {}, never, never, never, never, "finished", string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
  readonly id: "trust-graph";
  readonly initial: "finished";
  readonly context: {};
  readonly states: {
    readonly finished: {
      readonly type: "final";
    };
  };
}>;
//#endregion
//#region src/modules/trust-graph/types.d.ts
/**
 * Configuration options for the trust-graph module.
 *
 * The trust-graph module requires no configuration — it is a backend-only
 * process that runs risk scoring analysis server-side. The SDK skips
 * immediately without any user interaction.
 */
type TrustGraphConfig = Record<string, never>;
//#endregion
export { type TrustGraphConfig, type TrustGraphFinishedState, type TrustGraphManager, type TrustGraphState, createTrustGraphManager, trustGraphMachine };