/**
 * MPLP Protocol v1.0.0 — Frozen Specification
 * Freeze Date: 2025-12-03
 * Status: FROZEN (no breaking changes permitted)
 * Governance: MPLP Protocol Governance Committee (MPGC)
 *
 * © 2026 Jearon Wong. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * http://www.apache.org/licenses/LICENSE-2.0
 */
/**
 * Convenience helper event interface used by this coordination package.
 * It is not a direct mirror of the canonical protocol event schemas.
 */
export interface MplpEvent {
    /** Event type identifier (e.g., "context.created", "plan.approved") */
    type: string;
    /** ISO 8601 timestamp when event was created */
    timestamp: string;
    /** Run identifier this event belongs to */
    runId: string;
    /** Optional module that emitted the event */
    module?: string;
    /** Event payload data */
    payload?: Record<string, unknown>;
}
/**
 * Convenience helper contract used to describe coordination flows in this package.
 * It is derived from protocol-aligned types and is not a protocol SSOT object.
 */
export interface FlowContract<TOutput = unknown> {
    id: string;
    name: string;
    description?: string;
    version: string;
    modules: string[];
}
/**
 * Single Agent Flow output structure.
 */
export interface SingleAgentFlowOutput {
    context: Record<string, unknown>;
    plan: Record<string, unknown>;
    confirm: Record<string, unknown>;
    trace: Record<string, unknown>;
}
/**
 * Convenience single-agent flow helper contract for this package.
 */
export declare const SingleAgentFlowContract: FlowContract<SingleAgentFlowOutput>;
/**
 * Module handler context passed to each module during flow execution.
 */
export interface ModuleHandlerContext {
    context?: Record<string, unknown>;
    plan?: Record<string, unknown>;
    confirm?: Record<string, unknown>;
    trace?: Record<string, unknown>;
    role?: Record<string, unknown>;
    extension?: Record<string, unknown>;
    dialog?: Record<string, unknown>;
    collab?: Record<string, unknown>;
    core?: Record<string, unknown>;
    network?: Record<string, unknown>;
}
/** Runtime coordination state alias consumed by downstream runtime helpers. */
export type CoordinationContext = ModuleHandlerContext & {
    ids?: {
        runId?: string;
        projectId?: string;
        correlationId?: string;
    };
    metadata?: Record<string, unknown>;
};
/**
 * Module handler result returned by each module.
 */
export interface ModuleHandlerResult<T = unknown> {
    output: T;
    events?: MplpEvent[];
}
/** Context module handler type. */
export type ContextModuleHandler = (params: {
    ctx: ModuleHandlerContext;
}) => Promise<ModuleHandlerResult<{
    context: Record<string, unknown>;
}>>;
/** Plan module handler type. */
export type PlanModuleHandler = (params: {
    ctx: ModuleHandlerContext;
}) => Promise<ModuleHandlerResult<{
    plan: Record<string, unknown>;
}>>;
/** Confirm module handler type. */
export type ConfirmModuleHandler = (params: {
    ctx: ModuleHandlerContext;
}) => Promise<ModuleHandlerResult<{
    confirm: Record<string, unknown>;
}>>;
/** Trace module handler type. */
export type TraceModuleHandler = (params: {
    ctx: ModuleHandlerContext;
}) => Promise<ModuleHandlerResult<{
    trace: Record<string, unknown>;
}>>;
/** Role module handler type. */
export type RoleModuleHandler = ModuleHandler<{
    role: Record<string, unknown>;
}>;
/** Extension module handler type. */
export type ExtensionModuleHandler = ModuleHandler<{
    extension: Record<string, unknown>;
}>;
/** Dialog module handler type. */
export type DialogModuleHandler = ModuleHandler<{
    dialog: Record<string, unknown>;
}>;
/** Collab module handler type. */
export type CollabModuleHandler = ModuleHandler<{
    collab: Record<string, unknown>;
}>;
/** Core module handler type. */
export type CoreModuleHandler = ModuleHandler<{
    core: Record<string, unknown>;
}>;
/** Network module handler type. */
export type NetworkModuleHandler = ModuleHandler<{
    network: Record<string, unknown>;
}>;
/** Generic module handler type. */
export type ModuleHandler<TOutput = unknown> = (params: {
    ctx: ModuleHandlerContext;
}) => Promise<ModuleHandlerResult<TOutput>>;
/** Create an MPLP event with current timestamp. */
export declare function createMplpEvent(type: string, runId: string, payload?: Record<string, unknown>, module?: string): MplpEvent;